text: /******/ (() => { // webpackBootstrap
  /******/ 	var __webpack_modules__ = ({
  
  /***/ 7821:
  /***/ (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__(8185);
  /**
   * 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
  
  /***/ }),
  
  /***/ 8041:
  /***/ (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__(7821);
  const file_command_1 = __nccwpck_require__(3724);
  const utils_1 = __nccwpck_require__(8185);
  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) {
      process.stdout.write(os.EOL);
      command_1.issueCommand('set-output', { name }, value);
  }
  exports.setOutput = setOutput;
  /**
   * Enables or disables the echoing of commands into stdout for the rest of the step.
   * Echoing is disabled by default if ACTIONS_STEP_DEBUG is not set.
   *
   */
  function setCommandEcho(enabled) {
      command_1.issue('echo', enabled ? 'on' : 'off');
  }
  exports.setCommandEcho = setCommandEcho;
  //-----------------------------------------------------------------------
  // Results
  //-----------------------------------------------------------------------
  /**
   * Sets the action status to failed.
   * When the action exits it will be with an exit code of 1
   * @param message add error issue message
   */
  function setFailed(message) {
      process.exitCode = ExitCode.Failure;
      error(message);
  }
  exports.setFailed = setFailed;
  //-----------------------------------------------------------------------
  // Logging Commands
  //-----------------------------------------------------------------------
  /**
   * Gets whether Actions Step Debug is on or not
   */
  function isDebug() {
      return process.env['RUNNER_DEBUG'] === '1';
  }
  exports.isDebug = isDebug;
  /**
   * Writes debug message to user log
   * @param message debug message
   */
  function debug(message) {
      command_1.issueCommand('debug', {}, message);
  }
  exports.debug = debug;
  /**
   * Adds an error issue
   * @param message error issue message. Errors will be converted to string via toString()
   */
  function error(message) {
      command_1.issue('error', message instanceof Error ? message.toString() : message);
  }
  exports.error = error;
  /**
   * Adds an warning issue
   * @param message warning issue message. Errors will be converted to string via toString()
   */
  function warning(message) {
      command_1.issue('warning', message instanceof Error ? message.toString() : message);
  }
  exports.warning = warning;
  /**
   * Writes info to log with console.log.
   * @param message info message
   */
  function info(message) {
      process.stdout.write(message + os.EOL);
  }
  exports.info = info;
  /**
   * Begin an output group.
   *
   * Output until the next `groupEnd` will be foldable in this group
   *
   * @param name The name of the output group
   */
  function startGroup(name) {
      command_1.issue('group', name);
  }
  exports.startGroup = startGroup;
  /**
   * End an output group.
   */
  function endGroup() {
      command_1.issue('endgroup');
  }
  exports.endGroup = endGroup;
  /**
   * Wrap an asynchronous function call in a group.
   *
   * Returns the same type as the function itself.
   *
   * @param name The name of the group
   * @param fn The function to wrap in the group
   */
  function group(name, fn) {
      return __awaiter(this, void 0, void 0, function* () {
          startGroup(name);
          let result;
          try {
              result = yield fn();
          }
          finally {
              endGroup();
          }
          return result;
      });
  }
  exports.group = group;
  //-----------------------------------------------------------------------
  // Wrapper action state
  //-----------------------------------------------------------------------
  /**
   * Saves state for current action, the state can only be retrieved by this action's post job execution.
   *
   * @param     name     name of the state to store
   * @param     value    value to store. Non-string values will be converted to a string via JSON.stringify
   */
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  function saveState(name, value) {
      command_1.issueCommand('save-state', { name }, value);
  }
  exports.saveState = saveState;
  /**
   * Gets the value of an state set by this action's main execution.
   *
   * @param     name     name of the state to get
   * @returns   string
   */
  function getState(name) {
      return process.env[`STATE_${name}`] || '';
  }
  exports.getState = getState;
  //# sourceMappingURL=core.js.map
  
  /***/ }),
  
  /***/ 3724:
  /***/ (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__(8185);
  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
  
  /***/ }),
  
  /***/ 8185:
  /***/ ((__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
  
  /***/ }),
  
  /***/ 1951:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  var Zip = __nccwpck_require__(8726);
  
  var _require = __nccwpck_require__(8110),
      mapInfoResource = _require.mapInfoResource,
      findAarIconPath = _require.findAarIconPath,
      getBase64FromBuffer = _require.getBase64FromBuffer;
  
  var ManifestName = /^androidmanifest\.xml$/;
  var ResourceName = /^resources\.arsc$/;
  
  var ManifestXmlParser = __nccwpck_require__(5969);
  
  var ResourceFinder = __nccwpck_require__(5476);
  
  var AarParser = /*#__PURE__*/function (_Zip) {
    _inherits(AarParser, _Zip);
  
    var _super = _createSuper(AarParser);
  
    /**
     * parser for parsing .aar file
     * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
     */
    function AarParser(file) {
      var _this;
  
      _classCallCheck(this, AarParser);
  
      _this = _super.call(this, file);
  
      if (!(_assertThisInitialized(_this) instanceof AarParser)) {
        return _possibleConstructorReturn(_this, new AarParser(file));
      }
  
      return _this;
    }
  
    _createClass(AarParser, [{
      key: "parse",
      value: function parse() {
        var _this2 = this;
  
        return new Promise(function (resolve, reject) {
          _this2.getEntries([ManifestName]).then(function (buffers) {
            if (!buffers[ManifestName]) {
              throw new Error('AndroidManifest.xml can\'t be found.');
            }
  
            var aarInfo = _this2._parseManifest(buffers[ManifestName]);
  
            var resourceMap;
  
            if (!buffers[ResourceName]) {
              resolve(aarInfo);
            } else {
              // parse resourceMap
              resourceMap = _this2._parseResourceMap(buffers[ResourceName]); // update aarInfo with resourceMap
  
              aarInfo = mapInfoResource(aarInfo, resourceMap); // find icon path and parse icon
  
              var iconPath = findAarIconPath(aarInfo);
  
              if (iconPath) {
                _this2.getEntry(iconPath).then(function (iconBuffer) {
                  aarInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null;
                  resolve(aarInfo);
                })["catch"](function (e) {
                  aarInfo.icon = null;
                  resolve(aarInfo);
                  console.warn('[Warning] failed to parse icon: ', e);
                });
              } else {
                aarInfo.icon = null;
                resolve(aarInfo);
              }
            }
          })["catch"](function (e) {
            reject(e);
          });
        });
      }
      /**
       * Parse manifest
       * @param {Buffer} buffer // manifest file's buffer
       */
  
    }, {
      key: "_parseManifest",
      value: function _parseManifest(buffer) {
        try {
          var parser = new ManifestXmlParser(buffer, {
            ignore: ['application.activity', 'application.service', 'application.receiver', 'application.provider', 'permission-group']
          });
          return parser.parse();
        } catch (e) {
          console.error(e);
          throw new Error('Parse AndroidManifest.xml error: ', e);
        }
      }
      /**
       * Parse resourceMap
       * @param {Buffer} buffer // resourceMap file's buffer
       */
  
    }, {
      key: "_parseResourceMap",
      value: function _parseResourceMap(buffer) {
        try {
          return new ResourceFinder().processResourceTable(buffer);
        } catch (e) {
          throw new Error('Parser resources.arsc error: ' + e);
        }
      }
    }]);
  
    return AarParser;
  }(Zip);
  
  module.exports = AarParser;
  
  /***/ }),
  
  /***/ 3792:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  var Zip = __nccwpck_require__(8726);
  
  var _require = __nccwpck_require__(8110),
      mapInfoResource = _require.mapInfoResource,
      findApkIconPath = _require.findApkIconPath,
      getBase64FromBuffer = _require.getBase64FromBuffer;
  
  var ManifestName = /^androidmanifest\.xml$/;
  var ResourceName = /^resources\.arsc$/;
  
  var ManifestXmlParser = __nccwpck_require__(5969);
  
  var ResourceFinder = __nccwpck_require__(5476);
  
  var ApkParser = /*#__PURE__*/function (_Zip) {
    _inherits(ApkParser, _Zip);
  
    var _super = _createSuper(ApkParser);
  
    /**
     * parser for parsing .apk file
     * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
     */
    function ApkParser(file) {
      var _this;
  
      _classCallCheck(this, ApkParser);
  
      _this = _super.call(this, file);
  
      if (!(_assertThisInitialized(_this) instanceof ApkParser)) {
        return _possibleConstructorReturn(_this, new ApkParser(file));
      }
  
      return _this;
    }
  
    _createClass(ApkParser, [{
      key: "parse",
      value: function parse() {
        var _this2 = this;
  
        return new Promise(function (resolve, reject) {
          _this2.getEntries([ManifestName, ResourceName]).then(function (buffers) {
            if (!buffers[ManifestName]) {
              throw new Error('AndroidManifest.xml can\'t be found.');
            }
  
            var apkInfo = _this2._parseManifest(buffers[ManifestName]);
  
            var resourceMap;
  
            if (!buffers[ResourceName]) {
              resolve(apkInfo);
            } else {
              // parse resourceMap
              resourceMap = _this2._parseResourceMap(buffers[ResourceName]); // update apkInfo with resourceMap
  
              apkInfo = mapInfoResource(apkInfo, resourceMap); // find icon path and parse icon
  
              var iconPath = findApkIconPath(apkInfo);
  
              if (iconPath) {
                _this2.getEntry(iconPath).then(function (iconBuffer) {
                  apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null;
                  resolve(apkInfo);
                })["catch"](function (e) {
                  apkInfo.icon = null;
                  resolve(apkInfo);
                  console.warn('[Warning] failed to parse icon: ', e);
                });
              } else {
                apkInfo.icon = null;
                resolve(apkInfo);
              }
            }
          })["catch"](function (e) {
            reject(e);
          });
        });
      }
      /**
       * Parse manifest
       * @param {Buffer} buffer // manifest file's buffer
       */
  
    }, {
      key: "_parseManifest",
      value: function _parseManifest(buffer) {
        try {
          var parser = new ManifestXmlParser(buffer, {
            ignore: ['application.activity', 'application.service', 'application.receiver', 'application.provider', 'permission-group']
          });
          return parser.parse();
        } catch (e) {
          throw new Error('Parse AndroidManifest.xml error: ', e);
        }
      }
      /**
       * Parse resourceMap
       * @param {Buffer} buffer // resourceMap file's buffer
       */
  
    }, {
      key: "_parseResourceMap",
      value: function _parseResourceMap(buffer) {
        try {
          return new ResourceFinder().processResourceTable(buffer);
        } catch (e) {
          throw new Error('Parser resources.arsc error: ' + e);
        }
      }
    }]);
  
    return ApkParser;
  }(Zip);
  
  module.exports = ApkParser;
  
  /***/ }),
  
  /***/ 4355:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var ApkParser = __nccwpck_require__(3792);
  
  var AarParser = __nccwpck_require__(1951);
  
  var IpaParser = __nccwpck_require__(8167);
  
  var supportFileTypes = ['ipa', 'apk', 'aar'];
  
  var AppInfoParser = /*#__PURE__*/function () {
    /**
     * parser for parsing .ipa or .apk file
     * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
     */
    function AppInfoParser(file) {
      _classCallCheck(this, AppInfoParser);
  
      if (!file) {
        throw new Error('Param miss: file(file\'s path in Node, instance of File or Blob in browser).');
      }
  
      var splits = (file.name || file).split('.');
      var fileType = splits[splits.length - 1].toLowerCase();
  
      if (!supportFileTypes.includes(fileType)) {
        throw new Error('Unsupported file type, only support .ipa or .apk file.');
      }
  
      this.file = file;
  
      switch (fileType) {
        case 'ipa':
          this.parser = new IpaParser(this.file);
          break;
  
        case 'apk':
          this.parser = new ApkParser(this.file);
          break;
  
        case 'aar':
          this.parser = new AarParser(this.file);
          break;
      }
    }
  
    _createClass(AppInfoParser, [{
      key: "parse",
      value: function parse() {
        return this.parser.parse();
      }
    }]);
  
    return AppInfoParser;
  }();
  
  module.exports = AppInfoParser;
  
  /***/ }),
  
  /***/ 8167:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
  
  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
  
  function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
  
  function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
  
  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
  
  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
  
  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
  
  var parsePlist = __nccwpck_require__(272).parse;
  
  var parseBplist = __nccwpck_require__(747)/* .parseBuffer */ .yY;
  
  var cgbiToPng = __nccwpck_require__(9107);
  
  var Zip = __nccwpck_require__(8726);
  
  var _require = __nccwpck_require__(8110),
      findIpaIconPath = _require.findIpaIconPath,
      getBase64FromBuffer = _require.getBase64FromBuffer,
      isBrowser = _require.isBrowser;
  
  var PlistName = new RegExp('payload/.+?.app/info.plist$', 'i');
  var ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
  
  var IpaParser = /*#__PURE__*/function (_Zip) {
    _inherits(IpaParser, _Zip);
  
    var _super = _createSuper(IpaParser);
  
    /**
     * parser for parsing .ipa file
     * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
     */
    function IpaParser(file) {
      var _this;
  
      _classCallCheck(this, IpaParser);
  
      _this = _super.call(this, file);
  
      if (!(_assertThisInitialized(_this) instanceof IpaParser)) {
        return _possibleConstructorReturn(_this, new IpaParser(file));
      }
  
      return _this;
    }
  
    _createClass(IpaParser, [{
      key: "parse",
      value: function parse() {
        var _this2 = this;
  
        return new Promise(function (resolve, reject) {
          _this2.getEntries([PlistName, ProvisionName]).then(function (buffers) {
            if (!buffers[PlistName]) {
              throw new Error('Info.plist can\'t be found.');
            }
  
            var plistInfo = _this2._parsePlist(buffers[PlistName]); // parse mobile provision
  
  
            var provisionInfo = _this2._parseProvision(buffers[ProvisionName]);
  
            plistInfo.mobileProvision = provisionInfo; // find icon path and parse icon
  
            var iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase());
  
            _this2.getEntry(iconRegex).then(function (iconBuffer) {
              try {
                // In general, the ipa file's icon has been specially processed, should be converted
                plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null;
              } catch (err) {
                if (isBrowser()) {
                  // Normal conversion in other cases
                  plistInfo.icon = iconBuffer ? getBase64FromBuffer(window.btoa(String.fromCharCode.apply(String, _toConsumableArray(iconBuffer)))) : null;
                } else {
                  plistInfo.icon = null;
                  console.warn('[Warning] failed to parse icon: ', err);
                }
              }
  
              resolve(plistInfo);
            })["catch"](function (e) {
              reject(e);
            });
          })["catch"](function (e) {
            reject(e);
          });
        });
      }
      /**
       * Parse plist
       * @param {Buffer} buffer // plist file's buffer
       */
  
    }, {
      key: "_parsePlist",
      value: function _parsePlist(buffer) {
        var result;
        var bufferType = buffer[0];
  
        if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
          result = parsePlist(buffer.toString());
        } else if (bufferType === 98) {
          result = parseBplist(buffer)[0];
        } else {
          throw new Error('Unknown plist buffer type.');
        }
  
        return result;
      }
      /**
       * parse provision
       * @param {Buffer} buffer // provision file's buffer
       */
  
    }, {
      key: "_parseProvision",
      value: function _parseProvision(buffer) {
        var info = {};
  
        if (buffer) {
          var content = buffer.toString('utf-8');
          var firstIndex = content.indexOf('<?xml');
          var endIndex = content.indexOf('</plist>');
          content = content.slice(firstIndex, endIndex + 8);
  
          if (content) {
            info = parsePlist(content);
          }
        }
  
        return info;
      }
    }]);
  
    return IpaParser;
  }(Zip);
  
  module.exports = IpaParser;
  
  /***/ }),
  
  /***/ 5476:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  /**
   * Code translated from a C# project https://github.com/hylander0/Iteedee.ApkReader/blob/master/Iteedee.ApkReader/ApkResourceFinder.cs
   *
   * Decode binary file `resources.arsc` from a .apk file to a JavaScript Object.
   */
  var ByteBuffer = __nccwpck_require__(1327);
  
  var DEBUG = false;
  var RES_STRING_POOL_TYPE = 0x0001;
  var RES_TABLE_TYPE = 0x0002;
  var RES_TABLE_PACKAGE_TYPE = 0x0200;
  var RES_TABLE_TYPE_TYPE = 0x0201;
  var RES_TABLE_TYPE_SPEC_TYPE = 0x0202; // The 'data' holds a ResTable_ref, a reference to another resource
  // table entry.
  
  var TYPE_REFERENCE = 0x01; // The 'data' holds an index into the containing resource table's
  // global value string pool.
  
  var TYPE_STRING = 0x03;
  
  function ResourceFinder() {
    this.valueStringPool = null;
    this.typeStringPool = null;
    this.keyStringPool = null;
    this.package_id = 0;
    this.responseMap = {};
    this.entryMap = {};
  }
  /**
   * Same to C# BinaryReader.readBytes
   *
   * @param bb ByteBuffer
   * @param len length
   * @returns {Buffer}
   */
  
  
  ResourceFinder.readBytes = function (bb, len) {
    var uint8Array = new Uint8Array(len);
  
    for (var i = 0; i < len; i++) {
      uint8Array[i] = bb.readUint8();
    }
  
    return ByteBuffer.wrap(uint8Array, "binary", true);
  }; //
  
  /**
   *
   * @param {ByteBuffer} bb
   * @return {Map<String, Set<String>>}
   */
  
  
  ResourceFinder.prototype.processResourceTable = function (resourceBuffer) {
    var bb = ByteBuffer.wrap(resourceBuffer, "binary", true); // Resource table structure
  
    var type = bb.readShort(),
        headerSize = bb.readShort(),
        size = bb.readInt(),
        packageCount = bb.readInt(),
        buffer,
        bb2;
  
    if (type != RES_TABLE_TYPE) {
      throw new Error("No RES_TABLE_TYPE found!");
    }
  
    if (size != bb.limit) {
      throw new Error("The buffer size not matches to the resource table size.");
    }
  
    bb.offset = headerSize;
    var realStringPoolCount = 0,
        realPackageCount = 0;
  
    while (true) {
      var pos, t, hs, s;
  
      try {
        pos = bb.offset;
        t = bb.readShort();
        hs = bb.readShort();
        s = bb.readInt();
      } catch (e) {
        break;
      }
  
      if (t == RES_STRING_POOL_TYPE) {
        // Process the string pool
        if (realStringPoolCount == 0) {
          // Only the first string pool is processed.
          if (DEBUG) {
            console.log("Processing the string pool ...");
          }
  
          buffer = new ByteBuffer(s);
          bb.offset = pos;
          bb.prependTo(buffer);
          bb2 = ByteBuffer.wrap(buffer, "binary", true);
          bb2.LE();
          this.valueStringPool = this.processStringPool(bb2);
        }
  
        realStringPoolCount++;
      } else if (t == RES_TABLE_PACKAGE_TYPE) {
        // Process the package
        if (DEBUG) {
          console.log("Processing the package " + realPackageCount + " ...");
        }
  
        buffer = new ByteBuffer(s);
        bb.offset = pos;
        bb.prependTo(buffer);
        bb2 = ByteBuffer.wrap(buffer, "binary", true);
        bb2.LE();
        this.processPackage(bb2);
        realPackageCount++;
      } else {
        throw new Error("Unsupported type");
      }
  
      bb.offset = pos + s;
      if (!bb.remaining()) break;
    }
  
    if (realStringPoolCount != 1) {
      throw new Error("More than 1 string pool found!");
    }
  
    if (realPackageCount != packageCount) {
      throw new Error("Real package count not equals the declared count.");
    }
  
    return this.responseMap;
  };
  /**
   *
   * @param {ByteBuffer} bb
   */
  
  
  ResourceFinder.prototype.processPackage = function (bb) {
    // Package structure
    var type = bb.readShort(),
        headerSize = bb.readShort(),
        size = bb.readInt(),
        id = bb.readInt();
    this.package_id = id;
  
    for (var i = 0; i < 256; ++i) {
      bb.readUint8();
    }
  
    var typeStrings = bb.readInt(),
        lastPublicType = bb.readInt(),
        keyStrings = bb.readInt(),
        lastPublicKey = bb.readInt();
  
    if (typeStrings != headerSize) {
      throw new Error("TypeStrings must immediately following the package structure header.");
    }
  
    if (DEBUG) {
      console.log("Type strings:");
    }
  
    var lastPosition = bb.offset;
    bb.offset = typeStrings;
    var bbTypeStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
    bb.offset = lastPosition;
    this.typeStringPool = this.processStringPool(bbTypeStrings); // Key strings
  
    if (DEBUG) {
      console.log("Key strings:");
    }
  
    bb.offset = keyStrings;
    var key_type = bb.readShort(),
        key_headerSize = bb.readShort(),
        key_size = bb.readInt();
    lastPosition = bb.offset;
    bb.offset = keyStrings;
    var bbKeyStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
    bb.offset = lastPosition;
    this.keyStringPool = this.processStringPool(bbKeyStrings); // Iterate through all chunks
  
    var typeSpecCount = 0;
    var typeCount = 0;
    bb.offset = keyStrings + key_size;
    var bb2;
  
    while (true) {
      var pos = bb.offset;
  
      try {
        var t = bb.readShort();
        var hs = bb.readShort();
        var s = bb.readInt();
      } catch (e) {
        break;
      }
  
      if (t == RES_TABLE_TYPE_SPEC_TYPE) {
        bb.offset = pos;
        bb2 = ResourceFinder.readBytes(bb, s);
        this.processTypeSpec(bb2);
        typeSpecCount++;
      } else if (t == RES_TABLE_TYPE_TYPE) {
        bb.offset = pos;
        bb2 = ResourceFinder.readBytes(bb, s);
        this.processType(bb2);
        typeCount++;
      }
  
      if (s == 0) {
        break;
      }
  
      bb.offset = pos + s;
  
      if (!bb.remaining()) {
        break;
      }
    }
  };
  /**
   *
   * @param {ByteBuffer} bb
   */
  
  
  ResourceFinder.prototype.processType = function (bb) {
    var type = bb.readShort(),
        headerSize = bb.readShort(),
        size = bb.readInt(),
        id = bb.readByte(),
        res0 = bb.readByte(),
        res1 = bb.readShort(),
        entryCount = bb.readInt(),
        entriesStart = bb.readInt();
    var refKeys = {};
    var config_size = bb.readInt(); // Skip the config data
  
    bb.offset = headerSize;
  
    if (headerSize + entryCount * 4 != entriesStart) {
      throw new Error("HeaderSize, entryCount and entriesStart are not valid.");
    } // Start to get entry indices
  
  
    var entryIndices = new Array(entryCount);
  
    for (var i = 0; i < entryCount; ++i) {
      entryIndices[i] = bb.readInt();
    } // Get entries
  
  
    for (var i = 0; i < entryCount; ++i) {
      if (entryIndices[i] == -1) continue;
      var resource_id = this.package_id << 24 | id << 16 | i;
      var pos = bb.offset,
          entry_size,
          entry_flag,
          entry_key,
          value_size,
          value_res0,
          value_dataType,
          value_data;
  
      try {
        entry_size = bb.readShort();
        entry_flag = bb.readShort();
        entry_key = bb.readInt();
      } catch (e) {
        break;
      } // Get the value (simple) or map (complex)
  
  
      var FLAG_COMPLEX = 0x0001;
  
      if ((entry_flag & FLAG_COMPLEX) == 0) {
        // Simple case
        value_size = bb.readShort();
        value_res0 = bb.readByte();
        value_dataType = bb.readByte();
        value_data = bb.readInt();
        var idStr = Number(resource_id).toString(16);
        var keyStr = this.keyStringPool[entry_key];
        var data = null;
  
        if (DEBUG) {
          console.log("Entry 0x" + idStr + ", key: " + keyStr + ", simple value type: ");
        }
  
        var key = parseInt(idStr, 16);
        var entryArr = this.entryMap[key];
  
        if (entryArr == null) {
          entryArr = [];
        }
  
        entryArr.push(keyStr);
        this.entryMap[key] = entryArr;
  
        if (value_dataType == TYPE_STRING) {
          data = this.valueStringPool[value_data];
  
          if (DEBUG) {
            console.log(", data: " + this.valueStringPool[value_data] + "");
          }
        } else if (value_dataType == TYPE_REFERENCE) {
          var hexIndex = Number(value_data).toString(16);
          refKeys[idStr] = value_data;
        } else {
          data = "" + value_data;
  
          if (DEBUG) {
            console.log(", data: " + value_data + "");
          }
        }
  
        this.putIntoMap("@" + idStr, data);
      } else {
        // Complex case
        var entry_parent = bb.readInt();
        var entry_count = bb.readInt();
  
        for (var j = 0; j < entry_count; ++j) {
          var ref_name = bb.readInt();
          value_size = bb.readShort();
          value_res0 = bb.readByte();
          value_dataType = bb.readByte();
          value_data = bb.readInt();
        }
  
        if (DEBUG) {
          console.log("Entry 0x" + Number(resource_id).toString(16) + ", key: " + this.keyStringPool[entry_key] + ", complex value, not printed.");
        }
      }
    }
  
    for (var refK in refKeys) {
      var values = this.responseMap["@" + Number(refKeys[refK]).toString(16).toUpperCase()];
  
      if (values != null && Object.keys(values).length < 1000) {
        for (var value in values) {
          this.putIntoMap("@" + refK, value);
        }
      }
    }
  };
  /**
   *
   * @param {ByteBuffer} bb
   * @return {Array}
   */
  
  
  ResourceFinder.prototype.processStringPool = function (bb) {
    // String pool structure
    //
    var type = bb.readShort(),
        headerSize = bb.readShort(),
        size = bb.readInt(),
        stringCount = bb.readInt(),
        styleCount = bb.readInt(),
        flags = bb.readInt(),
        stringsStart = bb.readInt(),
        stylesStart = bb.readInt(),
        u16len,
        buffer;
    var isUTF_8 = (flags & 256) != 0;
    var offsets = new Array(stringCount);
  
    for (var i = 0; i < stringCount; ++i) {
      offsets[i] = bb.readInt();
    }
  
    var strings = new Array(stringCount);
  
    for (var i = 0; i < stringCount; ++i) {
      var pos = stringsStart + offsets[i];
      bb.offset = pos;
      strings[i] = "";
  
      if (isUTF_8) {
        u16len = bb.readUint8();
  
        if ((u16len & 0x80) != 0) {
          u16len = ((u16len & 0x7f) << 8) + bb.readUint8();
        }
  
        var u8len = bb.readUint8();
  
        if ((u8len & 0x80) != 0) {
          u8len = ((u8len & 0x7f) << 8) + bb.readUint8();
        }
  
        if (u8len > 0) {
          buffer = ResourceFinder.readBytes(bb, u8len);
  
          try {
            strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
          } catch (e) {
            if (DEBUG) {
              console.error(e);
              console.log("Error when turning buffer to utf-8 string.");
            }
          }
        } else {
          strings[i] = "";
        }
      } else {
        u16len = bb.readUint16();
  
        if ((u16len & 0x8000) != 0) {
          // larger than 32768
          u16len = ((u16len & 0x7fff) << 16) + bb.readUint16();
        }
  
        if (u16len > 0) {
          var len = u16len * 2;
          buffer = ResourceFinder.readBytes(bb, len);
  
          try {
            strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
          } catch (e) {
            if (DEBUG) {
              console.error(e);
              console.log("Error when turning buffer to utf-8 string.");
            }
          }
        }
      }
  
      if (DEBUG) {
        console.log("Parsed value: {0}", strings[i]);
      }
    }
  
    return strings;
  };
  /**
   *
   * @param {ByteBuffer} bb
   */
  
  
  ResourceFinder.prototype.processTypeSpec = function (bb) {
    var type = bb.readShort(),
        headerSize = bb.readShort(),
        size = bb.readInt(),
        id = bb.readByte(),
        res0 = bb.readByte(),
        res1 = bb.readShort(),
        entryCount = bb.readInt();
  
    if (DEBUG) {
      console.log("Processing type spec " + this.typeStringPool[id - 1] + "...");
    }
  
    var flags = new Array(entryCount);
  
    for (var i = 0; i < entryCount; ++i) {
      flags[i] = bb.readInt();
    }
  };
  
  ResourceFinder.prototype.putIntoMap = function (resId, value) {
    if (this.responseMap[resId.toUpperCase()] == null) {
      this.responseMap[resId.toUpperCase()] = [];
    }
  
    this.responseMap[resId.toUpperCase()].push(value);
  };
  
  module.exports = ResourceFinder;
  
  /***/ }),
  
  /***/ 8110:
  /***/ ((module) => {
  
  "use strict";
  
  
  function objectType(o) {
    return Object.prototype.toString.call(o).slice(8, -1).toLowerCase();
  }
  
  function isArray(o) {
    return objectType(o) === 'array';
  }
  
  function isObject(o) {
    return objectType(o) === 'object';
  }
  
  function isPrimitive(o) {
    return o === null || ['boolean', 'number', 'string', 'undefined'].includes(objectType(o));
  }
  
  function isBrowser() {
    return typeof window !== 'undefined' && typeof document !== 'undefined';
  }
  /**
   * map file place with resourceMap
   * @param {Object} apkInfo // json info parsed from .apk file
   * @param {Object} resourceMap // resourceMap
   */
  
  
  function mapInfoResource(apkInfo, resourceMap) {
    iteratorObj(apkInfo);
    return apkInfo;
  
    function iteratorObj(obj) {
      for (var i in obj) {
        if (isArray(obj[i])) {
          iteratorArray(obj[i]);
        } else if (isObject(obj[i])) {
          iteratorObj(obj[i]);
        } else if (isPrimitive(obj[i])) {
          if (isResources(obj[i])) {
            obj[i] = resourceMap[transKeyToMatchResourceMap(obj[i])];
          }
        }
      }
    }
  
    function iteratorArray(array) {
      var l = array.length;
  
      for (var i = 0; i < l; i++) {
        if (isArray(array[i])) {
          iteratorArray(array[i]);
        } else if (isObject(array[i])) {
          iteratorObj(array[i]);
        } else if (isPrimitive(array[i])) {
          if (isResources(array[i])) {
            array[i] = resourceMap[transKeyToMatchResourceMap(array[i])];
          }
        }
      }
    }
  
    function isResources(attrValue) {
      if (!attrValue) return false;
  
      if (typeof attrValue !== 'string') {
        attrValue = attrValue.toString();
      }
  
      return attrValue.indexOf('resourceId:') === 0;
    }
  
    function transKeyToMatchResourceMap(resourceId) {
      return '@' + resourceId.replace('resourceId:0x', '').toUpperCase();
    }
  }
  /**
   * find .apk file's icon path from json info
   * @param info // json info parsed from .apk file
   */
  
  
  function findApkIconPath(info) {
    if (!info.application.icon || !info.application.icon.splice) {
      return '';
    }
  
    var rulesMap = {
      mdpi: 48,
      hdpi: 72,
      xhdpi: 96,
      xxdpi: 144,
      xxxhdpi: 192
    };
    var resultMap = {};
    var maxDpiIcon = {
      dpi: 120,
      icon: ''
    };
  
    var _loop = function _loop(i) {
      info.application.icon.some(function (icon) {
        if (icon && icon.indexOf(i) !== -1) {
          resultMap['application-icon-' + rulesMap[i]] = icon;
          return true;
        }
      }); // get the maximal size icon
  
      if (resultMap['application-icon-' + rulesMap[i]] && rulesMap[i] >= maxDpiIcon.dpi) {
        maxDpiIcon.dpi = rulesMap[i];
        maxDpiIcon.icon = resultMap['application-icon-' + rulesMap[i]];
      }
    };
  
    for (var i in rulesMap) {
      _loop(i);
    }
  
    if (Object.keys(resultMap).length === 0 || !maxDpiIcon.icon) {
      maxDpiIcon.dpi = 120;
      maxDpiIcon.icon = info.application.icon[0] || '';
      resultMap['applicataion-icon-120'] = maxDpiIcon.icon;
    }
  
    return maxDpiIcon.icon;
  }
  /**
   * find .ipa file's icon path from json info
   * @param info // json info parsed from .ipa file
   */
  
  
  function findIpaIconPath(info) {
    if (info.CFBundleIcons && info.CFBundleIcons.CFBundlePrimaryIcon && info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles && info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length) {
      return info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles[info.CFBundleIcons.CFBundlePrimaryIcon.CFBundleIconFiles.length - 1];
    } else if (info.CFBundleIconFiles && info.CFBundleIconFiles.length) {
      return info.CFBundleIconFiles[info.CFBundleIconFiles.length - 1];
    } else {
      return '.app/Icon.png';
    }
  }
  /**
   * transform buffer to base64
   * @param {Buffer} buffer
   */
  
  
  function getBase64FromBuffer(buffer) {
    return 'data:image/png;base64,' + buffer.toString('base64');
  }
  /**
   * 去除unicode空字符
   * @param {String} str
   */
  
  
  function decodeNullUnicode(str) {
    if (typeof str === 'string') {
      // eslint-disable-next-line
      str = str.replace(/\u0000/g, '');
    }
  
    return str;
  }
  
  module.exports = {
    isArray: isArray,
    isObject: isObject,
    isPrimitive: isPrimitive,
    isBrowser: isBrowser,
    mapInfoResource: mapInfoResource,
    findApkIconPath: findApkIconPath,
    findIpaIconPath: findIpaIconPath,
    getBase64FromBuffer: getBase64FromBuffer,
    decodeNullUnicode: decodeNullUnicode
  };
  
  /***/ }),
  
  /***/ 309:
  /***/ ((module) => {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  // From https://github.com/openstf/adbkit-apkreader
  var NodeType = {
    ELEMENT_NODE: 1,
    ATTRIBUTE_NODE: 2,
    CDATA_SECTION_NODE: 4
  };
  var ChunkType = {
    NULL: 0x0000,
    STRING_POOL: 0x0001,
    TABLE: 0x0002,
    XML: 0x0003,
    XML_FIRST_CHUNK: 0x0100,
    XML_START_NAMESPACE: 0x0100,
    XML_END_NAMESPACE: 0x0101,
    XML_START_ELEMENT: 0x0102,
    XML_END_ELEMENT: 0x0103,
    XML_CDATA: 0x0104,
    XML_LAST_CHUNK: 0x017f,
    XML_RESOURCE_MAP: 0x0180,
    TABLE_PACKAGE: 0x0200,
    TABLE_TYPE: 0x0201,
    TABLE_TYPE_SPEC: 0x0202
  };
  var StringFlags = {
    SORTED: 1 << 0,
    UTF8: 1 << 8
  }; // Taken from android.util.TypedValue
  
  var TypedValue = {
    COMPLEX_MANTISSA_MASK: 0x00ffffff,
    COMPLEX_MANTISSA_SHIFT: 0x00000008,
    COMPLEX_RADIX_0p23: 0x00000003,
    COMPLEX_RADIX_16p7: 0x00000001,
    COMPLEX_RADIX_23p0: 0x00000000,
    COMPLEX_RADIX_8p15: 0x00000002,
    COMPLEX_RADIX_MASK: 0x00000003,
    COMPLEX_RADIX_SHIFT: 0x00000004,
    COMPLEX_UNIT_DIP: 0x00000001,
    COMPLEX_UNIT_FRACTION: 0x00000000,
    COMPLEX_UNIT_FRACTION_PARENT: 0x00000001,
    COMPLEX_UNIT_IN: 0x00000004,
    COMPLEX_UNIT_MASK: 0x0000000f,
    COMPLEX_UNIT_MM: 0x00000005,
    COMPLEX_UNIT_PT: 0x00000003,
    COMPLEX_UNIT_PX: 0x00000000,
    COMPLEX_UNIT_SHIFT: 0x00000000,
    COMPLEX_UNIT_SP: 0x00000002,
    DENSITY_DEFAULT: 0x00000000,
    DENSITY_NONE: 0x0000ffff,
    TYPE_ATTRIBUTE: 0x00000002,
    TYPE_DIMENSION: 0x00000005,
    TYPE_FIRST_COLOR_INT: 0x0000001c,
    TYPE_FIRST_INT: 0x00000010,
    TYPE_FLOAT: 0x00000004,
    TYPE_FRACTION: 0x00000006,
    TYPE_INT_BOOLEAN: 0x00000012,
    TYPE_INT_COLOR_ARGB4: 0x0000001e,
    TYPE_INT_COLOR_ARGB8: 0x0000001c,
    TYPE_INT_COLOR_RGB4: 0x0000001f,
    TYPE_INT_COLOR_RGB8: 0x0000001d,
    TYPE_INT_DEC: 0x00000010,
    TYPE_INT_HEX: 0x00000011,
    TYPE_LAST_COLOR_INT: 0x0000001f,
    TYPE_LAST_INT: 0x0000001f,
    TYPE_NULL: 0x00000000,
    TYPE_REFERENCE: 0x00000001,
    TYPE_STRING: 0x00000003
  };
  
  var BinaryXmlParser = /*#__PURE__*/function () {
    function BinaryXmlParser(buffer) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
      _classCallCheck(this, BinaryXmlParser);
  
      this.buffer = buffer;
      this.cursor = 0;
      this.strings = [];
      this.resources = [];
      this.document = null;
      this.parent = null;
      this.stack = [];
      this.debug = options.debug || false;
    }
  
    _createClass(BinaryXmlParser, [{
      key: "readU8",
      value: function readU8() {
        this.debug && console.group('readU8');
        this.debug && console.debug('cursor:', this.cursor);
        var val = this.buffer[this.cursor];
        this.debug && console.debug('value:', val);
        this.cursor += 1;
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readU16",
      value: function readU16() {
        this.debug && console.group('readU16');
        this.debug && console.debug('cursor:', this.cursor);
        var val = this.buffer.readUInt16LE(this.cursor);
        this.debug && console.debug('value:', val);
        this.cursor += 2;
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readS32",
      value: function readS32() {
        this.debug && console.group('readS32');
        this.debug && console.debug('cursor:', this.cursor);
        var val = this.buffer.readInt32LE(this.cursor);
        this.debug && console.debug('value:', val);
        this.cursor += 4;
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readU32",
      value: function readU32() {
        this.debug && console.group('readU32');
        this.debug && console.debug('cursor:', this.cursor);
        var val = this.buffer.readUInt32LE(this.cursor);
        this.debug && console.debug('value:', val);
        this.cursor += 4;
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readLength8",
      value: function readLength8() {
        this.debug && console.group('readLength8');
        var len = this.readU8();
  
        if (len & 0x80) {
          len = (len & 0x7f) << 8;
          len += this.readU8();
        }
  
        this.debug && console.debug('length:', len);
        this.debug && console.groupEnd();
        return len;
      }
    }, {
      key: "readLength16",
      value: function readLength16() {
        this.debug && console.group('readLength16');
        var len = this.readU16();
  
        if (len & 0x8000) {
          len = (len & 0x7fff) << 16;
          len += this.readU16();
        }
  
        this.debug && console.debug('length:', len);
        this.debug && console.groupEnd();
        return len;
      }
    }, {
      key: "readDimension",
      value: function readDimension() {
        this.debug && console.group('readDimension');
        var dimension = {
          value: null,
          unit: null,
          rawUnit: null
        };
        var value = this.readU32();
        var unit = dimension.value & 0xff;
        dimension.value = value >> 8;
        dimension.rawUnit = unit;
  
        switch (unit) {
          case TypedValue.COMPLEX_UNIT_MM:
            dimension.unit = 'mm';
            break;
  
          case TypedValue.COMPLEX_UNIT_PX:
            dimension.unit = 'px';
            break;
  
          case TypedValue.COMPLEX_UNIT_DIP:
            dimension.unit = 'dp';
            break;
  
          case TypedValue.COMPLEX_UNIT_SP:
            dimension.unit = 'sp';
            break;
  
          case TypedValue.COMPLEX_UNIT_PT:
            dimension.unit = 'pt';
            break;
  
          case TypedValue.COMPLEX_UNIT_IN:
            dimension.unit = 'in';
            break;
        }
  
        this.debug && console.groupEnd();
        return dimension;
      }
    }, {
      key: "readFraction",
      value: function readFraction() {
        this.debug && console.group('readFraction');
        var fraction = {
          value: null,
          type: null,
          rawType: null
        };
        var value = this.readU32();
        var type = value & 0xf;
        fraction.value = this.convertIntToFloat(value >> 4);
        fraction.rawType = type;
  
        switch (type) {
          case TypedValue.COMPLEX_UNIT_FRACTION:
            fraction.type = '%';
            break;
  
          case TypedValue.COMPLEX_UNIT_FRACTION_PARENT:
            fraction.type = '%p';
            break;
        }
  
        this.debug && console.groupEnd();
        return fraction;
      }
    }, {
      key: "readHex24",
      value: function readHex24() {
        this.debug && console.group('readHex24');
        var val = (this.readU32() & 0xffffff).toString(16);
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readHex32",
      value: function readHex32() {
        this.debug && console.group('readHex32');
        var val = this.readU32().toString(16);
        this.debug && console.groupEnd();
        return val;
      }
    }, {
      key: "readTypedValue",
      value: function readTypedValue() {
        this.debug && console.group('readTypedValue');
        var typedValue = {
          value: null,
          type: null,
          rawType: null
        };
        var start = this.cursor;
        var size = this.readU16();
        /* const zero = */
  
        this.readU8();
        var dataType = this.readU8(); // Yes, there has been a real world APK where the size is malformed.
  
        if (size === 0) {
          size = 8;
        }
  
        typedValue.rawType = dataType;
  
        switch (dataType) {
          case TypedValue.TYPE_INT_DEC:
            typedValue.value = this.readS32();
            typedValue.type = 'int_dec';
            break;
  
          case TypedValue.TYPE_INT_HEX:
            typedValue.value = this.readS32();
            typedValue.type = 'int_hex';
            break;
  
          case TypedValue.TYPE_STRING:
            var ref = this.readS32();
            typedValue.value = ref > 0 ? this.strings[ref] : '';
            typedValue.type = 'string';
            break;
  
          case TypedValue.TYPE_REFERENCE:
            var id = this.readU32();
            typedValue.value = "resourceId:0x".concat(id.toString(16));
            typedValue.type = 'reference';
            break;
  
          case TypedValue.TYPE_INT_BOOLEAN:
            typedValue.value = this.readS32() !== 0;
            typedValue.type = 'boolean';
            break;
  
          case TypedValue.TYPE_NULL:
            this.readU32();
            typedValue.value = null;
            typedValue.type = 'null';
            break;
  
          case TypedValue.TYPE_INT_COLOR_RGB8:
            typedValue.value = this.readHex24();
            typedValue.type = 'rgb8';
            break;
  
          case TypedValue.TYPE_INT_COLOR_RGB4:
            typedValue.value = this.readHex24();
            typedValue.type = 'rgb4';
            break;
  
          case TypedValue.TYPE_INT_COLOR_ARGB8:
            typedValue.value = this.readHex32();
            typedValue.type = 'argb8';
            break;
  
          case TypedValue.TYPE_INT_COLOR_ARGB4:
            typedValue.value = this.readHex32();
            typedValue.type = 'argb4';
            break;
  
          case TypedValue.TYPE_DIMENSION:
            typedValue.value = this.readDimension();
            typedValue.type = 'dimension';
            break;
  
          case TypedValue.TYPE_FRACTION:
            typedValue.value = this.readFraction();
            typedValue.type = 'fraction';
            break;
  
          default:
            {
              var type = dataType.toString(16);
              console.debug("Not sure what to do with typed value of type 0x".concat(type, ", falling back to reading an uint32."));
              typedValue.value = this.readU32();
              typedValue.type = 'unknown';
            }
        } // Ensure we consume the whole value
  
  
        var end = start + size;
  
        if (this.cursor !== end) {
          var _type = dataType.toString(16);
  
          var diff = end - this.cursor;
          console.debug("Cursor is off by ".concat(diff, " bytes at ").concat(this.cursor, " at supposed end of typed value of type 0x").concat(_type, ". The typed value started at offset ").concat(start, " and is supposed to end at offset ").concat(end, ". Ignoring the rest of the value."));
          this.cursor = end;
        }
  
        this.debug && console.groupEnd();
        return typedValue;
      } // https://twitter.com/kawasima/status/427730289201139712
  
    }, {
      key: "convertIntToFloat",
      value: function convertIntToFloat(_int) {
        var buf = new ArrayBuffer(4);
        new Int32Array(buf)[0] = _int;
        return new Float32Array(buf)[0];
      }
    }, {
      key: "readString",
      value: function readString(encoding) {
        this.debug && console.group('readString', encoding);
  
        switch (encoding) {
          case 'utf-8':
            var stringLength = this.readLength8(encoding);
            this.debug && console.debug('stringLength:', stringLength);
            var byteLength = this.readLength8(encoding);
            this.debug && console.debug('byteLength:', byteLength);
            var value = this.buffer.toString(encoding, this.cursor, this.cursor += byteLength);
            this.debug && console.debug('value:', value);
            this.debug && console.groupEnd();
            return value;
  
          case 'ucs2':
            stringLength = this.readLength16(encoding);
            this.debug && console.debug('stringLength:', stringLength);
            byteLength = stringLength * 2;
            this.debug && console.debug('byteLength:', byteLength);
            value = this.buffer.toString(encoding, this.cursor, this.cursor += byteLength);
            this.debug && console.debug('value:', value);
            this.debug && console.groupEnd();
            return value;
  
          default:
            throw new Error("Unsupported encoding '".concat(encoding, "'"));
        }
      }
    }, {
      key: "readChunkHeader",
      value: function readChunkHeader() {
        this.debug && console.group('readChunkHeader');
        var header = {
          startOffset: this.cursor,
          chunkType: this.readU16(),
          headerSize: this.readU16(),
          chunkSize: this.readU32()
        };
        this.debug && console.debug('startOffset:', header.startOffset);
        this.debug && console.debug('chunkType:', header.chunkType);
        this.debug && console.debug('headerSize:', header.headerSize);
        this.debug && console.debug('chunkSize:', header.chunkSize);
        this.debug && console.groupEnd();
        return header;
      }
    }, {
      key: "readStringPool",
      value: function readStringPool(header) {
        this.debug && console.group('readStringPool');
        header.stringCount = this.readU32();
        this.debug && console.debug('stringCount:', header.stringCount);
        header.styleCount = this.readU32();
        this.debug && console.debug('styleCount:', header.styleCount);
        header.flags = this.readU32();
        this.debug && console.debug('flags:', header.flags);
        header.stringsStart = this.readU32();
        this.debug && console.debug('stringsStart:', header.stringsStart);
        header.stylesStart = this.readU32();
        this.debug && console.debug('stylesStart:', header.stylesStart);
  
        if (header.chunkType !== ChunkType.STRING_POOL) {
          throw new Error('Invalid string pool header');
        }
  
        var offsets = [];
  
        for (var i = 0, l = header.stringCount; i < l; ++i) {
          this.debug && console.debug('offset:', i);
          offsets.push(this.readU32());
        }
  
        var sorted = (header.flags & StringFlags.SORTED) === StringFlags.SORTED;
        this.debug && console.debug('sorted:', sorted);
        var encoding = (header.flags & StringFlags.UTF8) === StringFlags.UTF8 ? 'utf-8' : 'ucs2';
        this.debug && console.debug('encoding:', encoding);
        var stringsStart = header.startOffset + header.stringsStart;
        this.cursor = stringsStart;
  
        for (var _i = 0, _l = header.stringCount; _i < _l; ++_i) {
          this.debug && console.debug('string:', _i);
          this.debug && console.debug('offset:', offsets[_i]);
          this.cursor = stringsStart + offsets[_i];
          this.strings.push(this.readString(encoding));
        } // Skip styles
  
  
        this.cursor = header.startOffset + header.chunkSize;
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "readResourceMap",
      value: function readResourceMap(header) {
        this.debug && console.group('readResourceMap');
        var count = Math.floor((header.chunkSize - header.headerSize) / 4);
  
        for (var i = 0; i < count; ++i) {
          this.resources.push(this.readU32());
        }
  
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "readXmlNamespaceStart",
      value: function readXmlNamespaceStart()
      /* header */
      {
        this.debug && console.group('readXmlNamespaceStart');
        /* const line = */
  
        this.readU32();
        /* const commentRef = */
  
        this.readU32();
        /* const prefixRef = */
  
        this.readS32();
        /* const uriRef = */
  
        this.readS32(); // We don't currently care about the values, but they could
        // be accessed like so:
        //
        // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
        // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
  
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "readXmlNamespaceEnd",
      value: function readXmlNamespaceEnd()
      /* header */
      {
        this.debug && console.group('readXmlNamespaceEnd');
        /* const line = */
  
        this.readU32();
        /* const commentRef = */
  
        this.readU32();
        /* const prefixRef = */
  
        this.readS32();
        /* const uriRef = */
  
        this.readS32(); // We don't currently care about the values, but they could
        // be accessed like so:
        //
        // namespaceURI.prefix = this.strings[prefixRef] // if prefixRef > 0
        // namespaceURI.uri = this.strings[uriRef] // if uriRef > 0
  
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "readXmlElementStart",
      value: function readXmlElementStart()
      /* header */
      {
        this.debug && console.group('readXmlElementStart');
        var node = {
          namespaceURI: null,
          nodeType: NodeType.ELEMENT_NODE,
          nodeName: null,
          attributes: [],
          childNodes: []
        };
        /* const line = */
  
        this.readU32();
        /* const commentRef = */
  
        this.readU32();
        var nsRef = this.readS32();
        var nameRef = this.readS32();
  
        if (nsRef > 0) {
          node.namespaceURI = this.strings[nsRef];
        }
  
        node.nodeName = this.strings[nameRef];
        /* const attrStart = */
  
        this.readU16();
        /* const attrSize = */
  
        this.readU16();
        var attrCount = this.readU16();
        /* const idIndex = */
  
        this.readU16();
        /* const classIndex = */
  
        this.readU16();
        /* const styleIndex = */
  
        this.readU16();
  
        for (var i = 0; i < attrCount; ++i) {
          node.attributes.push(this.readXmlAttribute());
        }
  
        if (this.document) {
          this.parent.childNodes.push(node);
          this.parent = node;
        } else {
          this.document = this.parent = node;
        }
  
        this.stack.push(node);
        this.debug && console.groupEnd();
        return node;
      }
    }, {
      key: "readXmlAttribute",
      value: function readXmlAttribute() {
        this.debug && console.group('readXmlAttribute');
        var attr = {
          namespaceURI: null,
          nodeType: NodeType.ATTRIBUTE_NODE,
          nodeName: null,
          name: null,
          value: null,
          typedValue: null
        };
        var nsRef = this.readS32();
        var nameRef = this.readS32();
        var valueRef = this.readS32();
  
        if (nsRef > 0) {
          attr.namespaceURI = this.strings[nsRef];
        }
  
        attr.nodeName = attr.name = this.strings[nameRef];
  
        if (valueRef > 0) {
          attr.value = this.strings[valueRef];
        }
  
        attr.typedValue = this.readTypedValue();
        this.debug && console.groupEnd();
        return attr;
      }
    }, {
      key: "readXmlElementEnd",
      value: function readXmlElementEnd()
      /* header */
      {
        this.debug && console.group('readXmlCData');
        /* const line = */
  
        this.readU32();
        /* const commentRef = */
  
        this.readU32();
        /* const nsRef = */
  
        this.readS32();
        /* const nameRef = */
  
        this.readS32();
        this.stack.pop();
        this.parent = this.stack[this.stack.length - 1];
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "readXmlCData",
      value: function readXmlCData()
      /* header */
      {
        this.debug && console.group('readXmlCData');
        var cdata = {
          namespaceURI: null,
          nodeType: NodeType.CDATA_SECTION_NODE,
          nodeName: '#cdata',
          data: null,
          typedValue: null
        };
        /* const line = */
  
        this.readU32();
        /* const commentRef = */
  
        this.readU32();
        var dataRef = this.readS32();
  
        if (dataRef > 0) {
          cdata.data = this.strings[dataRef];
        }
  
        cdata.typedValue = this.readTypedValue();
        this.parent.childNodes.push(cdata);
        this.debug && console.groupEnd();
        return cdata;
      }
    }, {
      key: "readNull",
      value: function readNull(header) {
        this.debug && console.group('readNull');
        this.cursor += header.chunkSize - header.headerSize;
        this.debug && console.groupEnd();
        return null;
      }
    }, {
      key: "parse",
      value: function parse() {
        this.debug && console.group('BinaryXmlParser.parse');
        var xmlHeader = this.readChunkHeader();
  
        if (xmlHeader.chunkType !== ChunkType.XML) {
          throw new Error('Invalid XML header');
        }
  
        while (this.cursor < this.buffer.length) {
          this.debug && console.group('chunk');
          var start = this.cursor;
          var header = this.readChunkHeader();
  
          switch (header.chunkType) {
            case ChunkType.STRING_POOL:
              this.readStringPool(header);
              break;
  
            case ChunkType.XML_RESOURCE_MAP:
              this.readResourceMap(header);
              break;
  
            case ChunkType.XML_START_NAMESPACE:
              this.readXmlNamespaceStart(header);
              break;
  
            case ChunkType.XML_END_NAMESPACE:
              this.readXmlNamespaceEnd(header);
              break;
  
            case ChunkType.XML_START_ELEMENT:
              this.readXmlElementStart(header);
              break;
  
            case ChunkType.XML_END_ELEMENT:
              this.readXmlElementEnd(header);
              break;
  
            case ChunkType.XML_CDATA:
              this.readXmlCData(header);
              break;
  
            case ChunkType.NULL:
              this.readNull(header);
              break;
  
            default:
              throw new Error("Unsupported chunk type '".concat(header.chunkType, "'"));
          } // Ensure we consume the whole chunk
  
  
          var end = start + header.chunkSize;
  
          if (this.cursor !== end) {
            var diff = end - this.cursor;
            var type = header.chunkType.toString(16);
            console.debug("Cursor is off by ".concat(diff, " bytes at ").concat(this.cursor, " at supposed end of chunk of type 0x").concat(type, ". The chunk started at offset ").concat(start, " and is supposed to end at offset ").concat(end, ". Ignoring the rest of the chunk."));
            this.cursor = end;
          }
  
          this.debug && console.groupEnd();
        }
  
        this.debug && console.groupEnd();
        return this.document;
      }
    }]);
  
    return BinaryXmlParser;
  }();
  
  module.exports = BinaryXmlParser;
  
  /***/ }),
  
  /***/ 5969:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  // From https://github.com/openstf/adbkit-apkreader
  var BinaryXmlParser = __nccwpck_require__(309);
  
  var TextXmlParser = __nccwpck_require__(8513);
  
  var INTENT_MAIN = 'android.intent.action.MAIN';
  var CATEGORY_LAUNCHER = 'android.intent.category.LAUNCHER';
  
  var ManifestParser = /*#__PURE__*/function () {
    function ManifestParser(buffer) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
      _classCallCheck(this, ManifestParser);
  
      this.buffer = buffer;
      this.isText = buffer[0] === 0x3c && buffer[1] === 0x3f;
  
      if (this.isText) {
        this.xmlParser = new TextXmlParser(this.buffer, options);
      } else {
        this.xmlParser = new BinaryXmlParser(this.buffer, options);
      }
    }
  
    _createClass(ManifestParser, [{
      key: "collapseAttributes",
      value: function collapseAttributes(element) {
        var collapsed = Object.create(null);
  
        for (var _i = 0, _Array$from = Array.from(element.attributes); _i < _Array$from.length; _i++) {
          var attr = _Array$from[_i];
          collapsed[attr.name] = attr.typedValue.value;
        }
  
        return collapsed;
      }
    }, {
      key: "parseIntents",
      value: function parseIntents(element, target) {
        var _this = this;
  
        target.intentFilters = [];
        target.metaData = [];
        return element.childNodes.forEach(function (element) {
          switch (element.nodeName) {
            case 'intent-filter':
              {
                var intentFilter = _this.collapseAttributes(element);
  
                intentFilter.actions = [];
                intentFilter.categories = [];
                intentFilter.data = [];
                element.childNodes.forEach(function (element) {
                  switch (element.nodeName) {
                    case 'action':
                      intentFilter.actions.push(_this.collapseAttributes(element));
                      break;
  
                    case 'category':
                      intentFilter.categories.push(_this.collapseAttributes(element));
                      break;
  
                    case 'data':
                      intentFilter.data.push(_this.collapseAttributes(element));
                      break;
                  }
                });
                target.intentFilters.push(intentFilter);
                break;
              }
  
            case 'meta-data':
              target.metaData.push(_this.collapseAttributes(element));
              break;
          }
        });
      }
    }, {
      key: "parseApplication",
      value: function parseApplication(element) {
        var _this2 = this;
  
        var app = this.collapseAttributes(element);
        app.activities = [];
        app.activityAliases = [];
        app.launcherActivities = [];
        app.services = [];
        app.receivers = [];
        app.providers = [];
        app.usesLibraries = [];
        app.metaData = [];
        element.childNodes.forEach(function (element) {
          switch (element.nodeName) {
            case 'activity':
              {
                var activity = _this2.collapseAttributes(element);
  
                _this2.parseIntents(element, activity);
  
                app.activities.push(activity);
  
                if (_this2.isLauncherActivity(activity)) {
                  app.launcherActivities.push(activity);
                }
  
                break;
              }
  
            case 'activity-alias':
              {
                var activityAlias = _this2.collapseAttributes(element);
  
                _this2.parseIntents(element, activityAlias);
  
                app.activityAliases.push(activityAlias);
  
                if (_this2.isLauncherActivity(activityAlias)) {
                  app.launcherActivities.push(activityAlias);
                }
  
                break;
              }
  
            case 'service':
              {
                var service = _this2.collapseAttributes(element);
  
                _this2.parseIntents(element, service);
  
                app.services.push(service);
                break;
              }
  
            case 'receiver':
              {
                var receiver = _this2.collapseAttributes(element);
  
                _this2.parseIntents(element, receiver);
  
                app.receivers.push(receiver);
                break;
              }
  
            case 'provider':
              {
                var provider = _this2.collapseAttributes(element);
  
                provider.grantUriPermissions = [];
                provider.metaData = [];
                provider.pathPermissions = [];
                element.childNodes.forEach(function (element) {
                  switch (element.nodeName) {
                    case 'grant-uri-permission':
                      provider.grantUriPermissions.push(_this2.collapseAttributes(element));
                      break;
  
                    case 'meta-data':
                      provider.metaData.push(_this2.collapseAttributes(element));
                      break;
  
                    case 'path-permission':
                      provider.pathPermissions.push(_this2.collapseAttributes(element));
                      break;
                  }
                });
                app.providers.push(provider);
                break;
              }
  
            case 'uses-library':
              app.usesLibraries.push(_this2.collapseAttributes(element));
              break;
  
            case 'meta-data':
              app.metaData.push(_this2.collapseAttributes(element));
              break;
          }
        });
        return app;
      }
    }, {
      key: "isLauncherActivity",
      value: function isLauncherActivity(activity) {
        return activity.intentFilters.some(function (filter) {
          var hasMain = filter.actions.some(function (action) {
            return action.name === INTENT_MAIN;
          });
  
          if (!hasMain) {
            return false;
          }
  
          return filter.categories.some(function (category) {
            return category.name === CATEGORY_LAUNCHER;
          });
        });
      }
    }, {
      key: "parse",
      value: function parse() {
        var _this3 = this;
  
        var document = this.xmlParser.parse().manifest[0];
        console.log(JSON.stringify(document, null, '\t'));
        var manifest;
  
        if (this.isText) {
          manifest = {};
          manifest["package"] = document.attr["package"];
          manifest.versionCode = document.attr['android:versionCode'];
          manifest.versionName = document.attr['android:versionName'];
          var permissions = document['uses-permission'];
  
          if (!!permissions && permissions.length > 0) {
            manifest.usesPermissions = permissions.map(function (attr) {
              return {
                name: attr['attr']['android:name']
              };
            });
          } else {
            manifest.usesPermissions = [];
          }
  
          var usesSdk = document['uses-sdk'][0]['attr'];
          manifest.usesSdk = {
            minSdkVersion: usesSdk['android:minSdkVersion'],
            targetSdkVersion: usesSdk['android:targetSdkVersion']
          };
          var application = document.application[0].attr;
          manifest.application = {
            debuggable: application['android:debuggable'],
            testOnly: application['android:detestOnlybuggable'],
            allowBackup: application['android:allowBackup'],
            supportsRtl: application['android:supportsRtl'],
            usesCleartextTraffic: application['android:usesCleartextTraffic']
          };
        } else {
          manifest = this.collapseAttributes(document);
          manifest.usesPermissions = [];
          manifest.permissions = [];
          manifest.permissionTrees = [];
          manifest.permissionGroups = [];
          manifest.instrumentation = null;
          manifest.usesSdk = null;
          manifest.usesConfiguration = null;
          manifest.usesFeatures = [];
          manifest.supportsScreens = null;
          manifest.compatibleScreens = [];
          manifest.supportsGlTextures = [];
          manifest.application = Object.create(null);
          document.childNodes.forEach(function (element) {
            switch (element.nodeName) {
              case 'uses-permission':
                manifest.usesPermissions.push(_this3.collapseAttributes(element));
                break;
  
              case 'permission':
                manifest.permissions.push(_this3.collapseAttributes(element));
                break;
  
              case 'permission-tree':
                manifest.permissionTrees.push(_this3.collapseAttributes(element));
                break;
  
              case 'permission-group':
                manifest.permissionGroups.push(_this3.collapseAttributes(element));
                break;
  
              case 'instrumentation':
                manifest.instrumentation = _this3.collapseAttributes(element);
                break;
  
              case 'uses-sdk':
                manifest.usesSdk = _this3.collapseAttributes(element);
                break;
  
              case 'uses-configuration':
                manifest.usesConfiguration = _this3.collapseAttributes(element);
                break;
  
              case 'uses-feature':
                manifest.usesFeatures.push(_this3.collapseAttributes(element));
                break;
  
              case 'supports-screens':
                manifest.supportsScreens = _this3.collapseAttributes(element);
                break;
  
              case 'compatible-screens':
                element.childNodes.forEach(function (screen) {
                  return manifest.compatibleScreens.push(_this3.collapseAttributes(screen));
                });
                break;
  
              case 'supports-gl-texture':
                manifest.supportsGlTextures.push(_this3.collapseAttributes(element));
                break;
  
              case 'application':
                manifest.application = _this3.parseApplication(element);
                break;
            }
          });
        }
  
        return manifest;
      }
    }]);
  
    return ManifestParser;
  }();
  
  module.exports = ManifestParser;
  
  /***/ }),
  
  /***/ 8513:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var FastXmlParser = __nccwpck_require__(4798);
  
  var he = __nccwpck_require__(5488);
  
  var Utf8XmlParser = /*#__PURE__*/function () {
    function Utf8XmlParser(buffer) {
      var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
  
      _classCallCheck(this, Utf8XmlParser);
  
      this.buffer = buffer;
      this.xml = buffer.toString();
      this.document = null;
      this.debug = options.debug || false;
    }
  
    _createClass(Utf8XmlParser, [{
      key: "parse",
      value: function parse() {
        // https://www.npmjs.com/package/fast-xml-parser
        var options = {
          attributeNamePrefix: '',
          attrNodeName: 'attr',
          // default is 'false'
          textNodeName: '#text',
          ignoreAttributes: false,
          ignoreNameSpace: false,
          allowBooleanAttributes: true,
          parseNodeValue: true,
          parseAttributeValue: true,
          trimValues: true,
          // cdataTagName: "__cdata", //default is 'false'
          // cdataPositionChar: "\\c",
          parseTrueNumberOnly: false,
          arrayMode: true,
          // "strict"
          attrValueProcessor: function attrValueProcessor(val, attrName) {
            return he.decode(val, {
              isAttributeValue: true
            });
          },
          // default is a=>a
          tagValueProcessor: function tagValueProcessor(val, tagName) {
            return he.decode(val);
          },
          // default is a=>a
          stopNodes: ['parse-me-as-string']
        };
        this.debug && console.group('Utf8XmlParser.parse');
        var tObj = FastXmlParser.getTraversalObj(this.xml, options);
        this.document = FastXmlParser.convertToJson(tObj, options);
        console.log(this.document);
        this.debug && console.groupEnd();
        return this.document;
      }
    }]);
  
    return Utf8XmlParser;
  }();
  
  module.exports = Utf8XmlParser;
  
  /***/ }),
  
  /***/ 8726:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var Unzip = __nccwpck_require__(7444);
  
  var _require = __nccwpck_require__(8110),
      isBrowser = _require.isBrowser,
      decodeNullUnicode = _require.decodeNullUnicode;
  
  var Zip = /*#__PURE__*/function () {
    function Zip(file) {
      _classCallCheck(this, Zip);
  
      if (isBrowser()) {
        if (!(file instanceof window.Blob || typeof file.size !== 'undefined')) {
          throw new Error('Param error: [file] must be an instance of Blob or File in browser.');
        }
  
        this.file = file;
      } else {
        if (typeof file !== 'string') {
          throw new Error('Param error: [file] must be file path in Node.');
        }
  
        this.file = __nccwpck_require__(5622).resolve(file);
      }
  
      this.unzip = new Unzip(this.file);
    }
    /**
     * get entries by regexps, the return format is: { <filename>: <Buffer|Blob> }
     * @param {Array} regexps // regexps for matching files
     * @param {String} type // return type, can be buffer or blob, default buffer
     */
  
  
    _createClass(Zip, [{
      key: "getEntries",
      value: function getEntries(regexps) {
        var _this = this;
  
        var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'buffer';
        regexps = regexps.map(function (regex) {
          return decodeNullUnicode(regex);
        });
        return new Promise(function (resolve, reject) {
          _this.unzip.getBuffer(regexps, {
            type: type
          }, function (err, buffers) {
            err ? reject(err) : resolve(buffers);
          });
        });
      }
      /**
       * get entry by regex, return an instance of Buffer or Blob
       * @param {Regex} regex // regex for matching file
       * @param {String} type // return type, can be buffer or blob, default buffer
       */
  
    }, {
      key: "getEntry",
      value: function getEntry(regex) {
        var _this2 = this;
  
        var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'buffer';
        regex = decodeNullUnicode(regex);
        return new Promise(function (resolve, reject) {
          _this2.unzip.getBuffer([regex], {
            type: type
          }, function (err, buffers) {
            err ? reject(err) : resolve(buffers[regex]);
          });
        });
      }
    }]);
  
    return Zip;
  }();
  
  module.exports = Zip;
  
  /***/ }),
  
  /***/ 2023:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  exports.byteLength = byteLength
  exports.toByteArray = toByteArray
  exports.fromByteArray = fromByteArray
  
  var lookup = []
  var revLookup = []
  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
  
  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  for (var i = 0, len = code.length; i < len; ++i) {
    lookup[i] = code[i]
    revLookup[code.charCodeAt(i)] = i
  }
  
  // Support decoding URL-safe base64 strings, as Node.js does.
  // See: https://en.wikipedia.org/wiki/Base64#URL_applications
  revLookup['-'.charCodeAt(0)] = 62
  revLookup['_'.charCodeAt(0)] = 63
  
  function getLens (b64) {
    var len = b64.length
  
    if (len % 4 > 0) {
      throw new Error('Invalid string. Length must be a multiple of 4')
    }
  
    // Trim off extra bytes after placeholder bytes are found
    // See: https://github.com/beatgammit/base64-js/issues/42
    var validLen = b64.indexOf('=')
    if (validLen === -1) validLen = len
  
    var placeHoldersLen = validLen === len
      ? 0
      : 4 - (validLen % 4)
  
    return [validLen, placeHoldersLen]
  }
  
  // base64 is 4/3 + up to two characters of the original data
  function byteLength (b64) {
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function _byteLength (b64, validLen, placeHoldersLen) {
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function toByteArray (b64) {
    var tmp
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
  
    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
  
    var curByte = 0
  
    // if there are placeholders, only get up to the last complete 4 chars
    var len = placeHoldersLen > 0
      ? validLen - 4
      : validLen
  
    var i
    for (i = 0; i < len; i += 4) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 18) |
        (revLookup[b64.charCodeAt(i + 1)] << 12) |
        (revLookup[b64.charCodeAt(i + 2)] << 6) |
        revLookup[b64.charCodeAt(i + 3)]
      arr[curByte++] = (tmp >> 16) & 0xFF
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 2) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 2) |
        (revLookup[b64.charCodeAt(i + 1)] >> 4)
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 1) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 10) |
        (revLookup[b64.charCodeAt(i + 1)] << 4) |
        (revLookup[b64.charCodeAt(i + 2)] >> 2)
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    return arr
  }
  
  function tripletToBase64 (num) {
    return lookup[num >> 18 & 0x3F] +
      lookup[num >> 12 & 0x3F] +
      lookup[num >> 6 & 0x3F] +
      lookup[num & 0x3F]
  }
  
  function encodeChunk (uint8, start, end) {
    var tmp
    var output = []
    for (var i = start; i < end; i += 3) {
      tmp =
        ((uint8[i] << 16) & 0xFF0000) +
        ((uint8[i + 1] << 8) & 0xFF00) +
        (uint8[i + 2] & 0xFF)
      output.push(tripletToBase64(tmp))
    }
    return output.join('')
  }
  
  function fromByteArray (uint8) {
    var tmp
    var len = uint8.length
    var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
    var parts = []
    var maxChunkLength = 16383 // must be multiple of 3
  
    // go through the array every three bytes, we'll deal with trailing stuff later
    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
      parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)))
    }
  
    // pad the end with zeros, but make sure to not forget the extra bytes
    if (extraBytes === 1) {
      tmp = uint8[len - 1]
      parts.push(
        lookup[tmp >> 2] +
        lookup[(tmp << 4) & 0x3F] +
        '=='
      )
    } else if (extraBytes === 2) {
      tmp = (uint8[len - 2] << 8) + uint8[len - 1]
      parts.push(
        lookup[tmp >> 10] +
        lookup[(tmp >> 4) & 0x3F] +
        lookup[(tmp << 2) & 0x3F] +
        '='
      )
    }
  
    return parts.join('')
  }
  
  
  /***/ }),
  
  /***/ 575:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /* module decorator */ module = __nccwpck_require__.nmd(module);
  var bigInt = (function (undefined) {
      "use strict";
  
      var BASE = 1e7,
          LOG_BASE = 7,
          MAX_INT = 9007199254740992,
          MAX_INT_ARR = smallToArray(MAX_INT),
          DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
  
      var supportsNativeBigInt = typeof BigInt === "function";
  
      function Integer(v, radix, alphabet, caseSensitive) {
          if (typeof v === "undefined") return Integer[0];
          if (typeof radix !== "undefined") return +radix === 10 && !alphabet ? parseValue(v) : parseBase(v, radix, alphabet, caseSensitive);
          return parseValue(v);
      }
  
      function BigInteger(value, sign) {
          this.value = value;
          this.sign = sign;
          this.isSmall = false;
      }
      BigInteger.prototype = Object.create(Integer.prototype);
  
      function SmallInteger(value) {
          this.value = value;
          this.sign = value < 0;
          this.isSmall = true;
      }
      SmallInteger.prototype = Object.create(Integer.prototype);
  
      function NativeBigInt(value) {
          this.value = value;
      }
      NativeBigInt.prototype = Object.create(Integer.prototype);
  
      function isPrecise(n) {
          return -MAX_INT < n && n < MAX_INT;
      }
  
      function smallToArray(n) { // For performance reasons doesn't reference BASE, need to change this function if BASE changes
          if (n < 1e7)
              return [n];
          if (n < 1e14)
              return [n % 1e7, Math.floor(n / 1e7)];
          return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
      }
  
      function arrayToSmall(arr) { // If BASE changes this function may need to change
          trim(arr);
          var length = arr.length;
          if (length < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
              switch (length) {
                  case 0: return 0;
                  case 1: return arr[0];
                  case 2: return arr[0] + arr[1] * BASE;
                  default: return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
              }
          }
          return arr;
      }
  
      function trim(v) {
          var i = v.length;
          while (v[--i] === 0);
          v.length = i + 1;
      }
  
      function createArray(length) { // function shamelessly stolen from Yaffle's library https://github.com/Yaffle/BigInteger
          var x = new Array(length);
          var i = -1;
          while (++i < length) {
              x[i] = 0;
          }
          return x;
      }
  
      function truncate(n) {
          if (n > 0) return Math.floor(n);
          return Math.ceil(n);
      }
  
      function add(a, b) { // assumes a and b are arrays with a.length >= b.length
          var l_a = a.length,
              l_b = b.length,
              r = new Array(l_a),
              carry = 0,
              base = BASE,
              sum, i;
          for (i = 0; i < l_b; i++) {
              sum = a[i] + b[i] + carry;
              carry = sum >= base ? 1 : 0;
              r[i] = sum - carry * base;
          }
          while (i < l_a) {
              sum = a[i] + carry;
              carry = sum === base ? 1 : 0;
              r[i++] = sum - carry * base;
          }
          if (carry > 0) r.push(carry);
          return r;
      }
  
      function addAny(a, b) {
          if (a.length >= b.length) return add(a, b);
          return add(b, a);
      }
  
      function addSmall(a, carry) { // assumes a is array, carry is number with 0 <= carry < MAX_INT
          var l = a.length,
              r = new Array(l),
              base = BASE,
              sum, i;
          for (i = 0; i < l; i++) {
              sum = a[i] - base + carry;
              carry = Math.floor(sum / base);
              r[i] = sum - carry * base;
              carry += 1;
          }
          while (carry > 0) {
              r[i++] = carry % base;
              carry = Math.floor(carry / base);
          }
          return r;
      }
  
      BigInteger.prototype.add = function (v) {
          var n = parseValue(v);
          if (this.sign !== n.sign) {
              return this.subtract(n.negate());
          }
          var a = this.value, b = n.value;
          if (n.isSmall) {
              return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
          }
          return new BigInteger(addAny(a, b), this.sign);
      };
      BigInteger.prototype.plus = BigInteger.prototype.add;
  
      SmallInteger.prototype.add = function (v) {
          var n = parseValue(v);
          var a = this.value;
          if (a < 0 !== n.sign) {
              return this.subtract(n.negate());
          }
          var b = n.value;
          if (n.isSmall) {
              if (isPrecise(a + b)) return new SmallInteger(a + b);
              b = smallToArray(Math.abs(b));
          }
          return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
      };
      SmallInteger.prototype.plus = SmallInteger.prototype.add;
  
      NativeBigInt.prototype.add = function (v) {
          return new NativeBigInt(this.value + parseValue(v).value);
      }
      NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
  
      function subtract(a, b) { // assumes a and b are arrays with a >= b
          var a_l = a.length,
              b_l = b.length,
              r = new Array(a_l),
              borrow = 0,
              base = BASE,
              i, difference;
          for (i = 0; i < b_l; i++) {
              difference = a[i] - borrow - b[i];
              if (difference < 0) {
                  difference += base;
                  borrow = 1;
              } else borrow = 0;
              r[i] = difference;
          }
          for (i = b_l; i < a_l; i++) {
              difference = a[i] - borrow;
              if (difference < 0) difference += base;
              else {
                  r[i++] = difference;
                  break;
              }
              r[i] = difference;
          }
          for (; i < a_l; i++) {
              r[i] = a[i];
          }
          trim(r);
          return r;
      }
  
      function subtractAny(a, b, sign) {
          var value;
          if (compareAbs(a, b) >= 0) {
              value = subtract(a, b);
          } else {
              value = subtract(b, a);
              sign = !sign;
          }
          value = arrayToSmall(value);
          if (typeof value === "number") {
              if (sign) value = -value;
              return new SmallInteger(value);
          }
          return new BigInteger(value, sign);
      }
  
      function subtractSmall(a, b, sign) { // assumes a is array, b is number with 0 <= b < MAX_INT
          var l = a.length,
              r = new Array(l),
              carry = -b,
              base = BASE,
              i, difference;
          for (i = 0; i < l; i++) {
              difference = a[i] + carry;
              carry = Math.floor(difference / base);
              difference %= base;
              r[i] = difference < 0 ? difference + base : difference;
          }
          r = arrayToSmall(r);
          if (typeof r === "number") {
              if (sign) r = -r;
              return new SmallInteger(r);
          } return new BigInteger(r, sign);
      }
  
      BigInteger.prototype.subtract = function (v) {
          var n = parseValue(v);
          if (this.sign !== n.sign) {
              return this.add(n.negate());
          }
          var a = this.value, b = n.value;
          if (n.isSmall)
              return subtractSmall(a, Math.abs(b), this.sign);
          return subtractAny(a, b, this.sign);
      };
      BigInteger.prototype.minus = BigInteger.prototype.subtract;
  
      SmallInteger.prototype.subtract = function (v) {
          var n = parseValue(v);
          var a = this.value;
          if (a < 0 !== n.sign) {
              return this.add(n.negate());
          }
          var b = n.value;
          if (n.isSmall) {
              return new SmallInteger(a - b);
          }
          return subtractSmall(b, Math.abs(a), a >= 0);
      };
      SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
  
      NativeBigInt.prototype.subtract = function (v) {
          return new NativeBigInt(this.value - parseValue(v).value);
      }
      NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;
  
      BigInteger.prototype.negate = function () {
          return new BigInteger(this.value, !this.sign);
      };
      SmallInteger.prototype.negate = function () {
          var sign = this.sign;
          var small = new SmallInteger(-this.value);
          small.sign = !sign;
          return small;
      };
      NativeBigInt.prototype.negate = function () {
          return new NativeBigInt(-this.value);
      }
  
      BigInteger.prototype.abs = function () {
          return new BigInteger(this.value, false);
      };
      SmallInteger.prototype.abs = function () {
          return new SmallInteger(Math.abs(this.value));
      };
      NativeBigInt.prototype.abs = function () {
          return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
      }
  
  
      function multiplyLong(a, b) {
          var a_l = a.length,
              b_l = b.length,
              l = a_l + b_l,
              r = createArray(l),
              base = BASE,
              product, carry, i, a_i, b_j;
          for (i = 0; i < a_l; ++i) {
              a_i = a[i];
              for (var j = 0; j < b_l; ++j) {
                  b_j = b[j];
                  product = a_i * b_j + r[i + j];
                  carry = Math.floor(product / base);
                  r[i + j] = product - carry * base;
                  r[i + j + 1] += carry;
              }
          }
          trim(r);
          return r;
      }
  
      function multiplySmall(a, b) { // assumes a is array, b is number with |b| < BASE
          var l = a.length,
              r = new Array(l),
              base = BASE,
              carry = 0,
              product, i;
          for (i = 0; i < l; i++) {
              product = a[i] * b + carry;
              carry = Math.floor(product / base);
              r[i] = product - carry * base;
          }
          while (carry > 0) {
              r[i++] = carry % base;
              carry = Math.floor(carry / base);
          }
          return r;
      }
  
      function shiftLeft(x, n) {
          var r = [];
          while (n-- > 0) r.push(0);
          return r.concat(x);
      }
  
      function multiplyKaratsuba(x, y) {
          var n = Math.max(x.length, y.length);
  
          if (n <= 30) return multiplyLong(x, y);
          n = Math.ceil(n / 2);
  
          var b = x.slice(n),
              a = x.slice(0, n),
              d = y.slice(n),
              c = y.slice(0, n);
  
          var ac = multiplyKaratsuba(a, c),
              bd = multiplyKaratsuba(b, d),
              abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));
  
          var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
          trim(product);
          return product;
      }
  
      // The following function is derived from a surface fit of a graph plotting the performance difference
      // between long multiplication and karatsuba multiplication versus the lengths of the two arrays.
      function useKaratsuba(l1, l2) {
          return -0.012 * l1 - 0.012 * l2 + 0.000015 * l1 * l2 > 0;
      }
  
      BigInteger.prototype.multiply = function (v) {
          var n = parseValue(v),
              a = this.value, b = n.value,
              sign = this.sign !== n.sign,
              abs;
          if (n.isSmall) {
              if (b === 0) return Integer[0];
              if (b === 1) return this;
              if (b === -1) return this.negate();
              abs = Math.abs(b);
              if (abs < BASE) {
                  return new BigInteger(multiplySmall(a, abs), sign);
              }
              b = smallToArray(abs);
          }
          if (useKaratsuba(a.length, b.length)) // Karatsuba is only faster for certain array sizes
              return new BigInteger(multiplyKaratsuba(a, b), sign);
          return new BigInteger(multiplyLong(a, b), sign);
      };
  
      BigInteger.prototype.times = BigInteger.prototype.multiply;
  
      function multiplySmallAndArray(a, b, sign) { // a >= 0
          if (a < BASE) {
              return new BigInteger(multiplySmall(b, a), sign);
          }
          return new BigInteger(multiplyLong(b, smallToArray(a)), sign);
      }
      SmallInteger.prototype._multiplyBySmall = function (a) {
          if (isPrecise(a.value * this.value)) {
              return new SmallInteger(a.value * this.value);
          }
          return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
      };
      BigInteger.prototype._multiplyBySmall = function (a) {
          if (a.value === 0) return Integer[0];
          if (a.value === 1) return this;
          if (a.value === -1) return this.negate();
          return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
      };
      SmallInteger.prototype.multiply = function (v) {
          return parseValue(v)._multiplyBySmall(this);
      };
      SmallInteger.prototype.times = SmallInteger.prototype.multiply;
  
      NativeBigInt.prototype.multiply = function (v) {
          return new NativeBigInt(this.value * parseValue(v).value);
      }
      NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
  
      function square(a) {
          //console.assert(2 * BASE * BASE < MAX_INT);
          var l = a.length,
              r = createArray(l + l),
              base = BASE,
              product, carry, i, a_i, a_j;
          for (i = 0; i < l; i++) {
              a_i = a[i];
              carry = 0 - a_i * a_i;
              for (var j = i; j < l; j++) {
                  a_j = a[j];
                  product = 2 * (a_i * a_j) + r[i + j] + carry;
                  carry = Math.floor(product / base);
                  r[i + j] = product - carry * base;
              }
              r[i + l] = carry;
          }
          trim(r);
          return r;
      }
  
      BigInteger.prototype.square = function () {
          return new BigInteger(square(this.value), false);
      };
  
      SmallInteger.prototype.square = function () {
          var value = this.value * this.value;
          if (isPrecise(value)) return new SmallInteger(value);
          return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
      };
  
      NativeBigInt.prototype.square = function (v) {
          return new NativeBigInt(this.value * this.value);
      }
  
      function divMod1(a, b) { // Left over from previous version. Performs faster than divMod2 on smaller input sizes.
          var a_l = a.length,
              b_l = b.length,
              base = BASE,
              result = createArray(b.length),
              divisorMostSignificantDigit = b[b_l - 1],
              // normalization
              lambda = Math.ceil(base / (2 * divisorMostSignificantDigit)),
              remainder = multiplySmall(a, lambda),
              divisor = multiplySmall(b, lambda),
              quotientDigit, shift, carry, borrow, i, l, q;
          if (remainder.length <= a_l) remainder.push(0);
          divisor.push(0);
          divisorMostSignificantDigit = divisor[b_l - 1];
          for (shift = a_l - b_l; shift >= 0; shift--) {
              quotientDigit = base - 1;
              if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
                  quotientDigit = Math.floor((remainder[shift + b_l] * base + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
              }
              // quotientDigit <= base - 1
              carry = 0;
              borrow = 0;
              l = divisor.length;
              for (i = 0; i < l; i++) {
                  carry += quotientDigit * divisor[i];
                  q = Math.floor(carry / base);
                  borrow += remainder[shift + i] - (carry - q * base);
                  carry = q;
                  if (borrow < 0) {
                      remainder[shift + i] = borrow + base;
                      borrow = -1;
                  } else {
                      remainder[shift + i] = borrow;
                      borrow = 0;
                  }
              }
              while (borrow !== 0) {
                  quotientDigit -= 1;
                  carry = 0;
                  for (i = 0; i < l; i++) {
                      carry += remainder[shift + i] - base + divisor[i];
                      if (carry < 0) {
                          remainder[shift + i] = carry + base;
                          carry = 0;
                      } else {
                          remainder[shift + i] = carry;
                          carry = 1;
                      }
                  }
                  borrow += carry;
              }
              result[shift] = quotientDigit;
          }
          // denormalization
          remainder = divModSmall(remainder, lambda)[0];
          return [arrayToSmall(result), arrayToSmall(remainder)];
      }
  
      function divMod2(a, b) { // Implementation idea shamelessly stolen from Silent Matt's library http://silentmatt.com/biginteger/
          // Performs faster than divMod1 on larger input sizes.
          var a_l = a.length,
              b_l = b.length,
              result = [],
              part = [],
              base = BASE,
              guess, xlen, highx, highy, check;
          while (a_l) {
              part.unshift(a[--a_l]);
              trim(part);
              if (compareAbs(part, b) < 0) {
                  result.push(0);
                  continue;
              }
              xlen = part.length;
              highx = part[xlen - 1] * base + part[xlen - 2];
              highy = b[b_l - 1] * base + b[b_l - 2];
              if (xlen > b_l) {
                  highx = (highx + 1) * base;
              }
              guess = Math.ceil(highx / highy);
              do {
                  check = multiplySmall(b, guess);
                  if (compareAbs(check, part) <= 0) break;
                  guess--;
              } while (guess);
              result.push(guess);
              part = subtract(part, check);
          }
          result.reverse();
          return [arrayToSmall(result), arrayToSmall(part)];
      }
  
      function divModSmall(value, lambda) {
          var length = value.length,
              quotient = createArray(length),
              base = BASE,
              i, q, remainder, divisor;
          remainder = 0;
          for (i = length - 1; i >= 0; --i) {
              divisor = remainder * base + value[i];
              q = truncate(divisor / lambda);
              remainder = divisor - q * lambda;
              quotient[i] = q | 0;
          }
          return [quotient, remainder | 0];
      }
  
      function divModAny(self, v) {
          var value, n = parseValue(v);
          if (supportsNativeBigInt) {
              return [new NativeBigInt(self.value / n.value), new NativeBigInt(self.value % n.value)];
          }
          var a = self.value, b = n.value;
          var quotient;
          if (b === 0) throw new Error("Cannot divide by zero");
          if (self.isSmall) {
              if (n.isSmall) {
                  return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
              }
              return [Integer[0], self];
          }
          if (n.isSmall) {
              if (b === 1) return [self, Integer[0]];
              if (b == -1) return [self.negate(), Integer[0]];
              var abs = Math.abs(b);
              if (abs < BASE) {
                  value = divModSmall(a, abs);
                  quotient = arrayToSmall(value[0]);
                  var remainder = value[1];
                  if (self.sign) remainder = -remainder;
                  if (typeof quotient === "number") {
                      if (self.sign !== n.sign) quotient = -quotient;
                      return [new SmallInteger(quotient), new SmallInteger(remainder)];
                  }
                  return [new BigInteger(quotient, self.sign !== n.sign), new SmallInteger(remainder)];
              }
              b = smallToArray(abs);
          }
          var comparison = compareAbs(a, b);
          if (comparison === -1) return [Integer[0], self];
          if (comparison === 0) return [Integer[self.sign === n.sign ? 1 : -1], Integer[0]];
  
          // divMod1 is faster on smaller input sizes
          if (a.length + b.length <= 200)
              value = divMod1(a, b);
          else value = divMod2(a, b);
  
          quotient = value[0];
          var qSign = self.sign !== n.sign,
              mod = value[1],
              mSign = self.sign;
          if (typeof quotient === "number") {
              if (qSign) quotient = -quotient;
              quotient = new SmallInteger(quotient);
          } else quotient = new BigInteger(quotient, qSign);
          if (typeof mod === "number") {
              if (mSign) mod = -mod;
              mod = new SmallInteger(mod);
          } else mod = new BigInteger(mod, mSign);
          return [quotient, mod];
      }
  
      BigInteger.prototype.divmod = function (v) {
          var result = divModAny(this, v);
          return {
              quotient: result[0],
              remainder: result[1]
          };
      };
      NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;
  
  
      BigInteger.prototype.divide = function (v) {
          return divModAny(this, v)[0];
      };
      NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function (v) {
          return new NativeBigInt(this.value / parseValue(v).value);
      };
      SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;
  
      BigInteger.prototype.mod = function (v) {
          return divModAny(this, v)[1];
      };
      NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function (v) {
          return new NativeBigInt(this.value % parseValue(v).value);
      };
      SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;
  
      BigInteger.prototype.pow = function (v) {
          var n = parseValue(v),
              a = this.value,
              b = n.value,
              value, x, y;
          if (b === 0) return Integer[1];
          if (a === 0) return Integer[0];
          if (a === 1) return Integer[1];
          if (a === -1) return n.isEven() ? Integer[1] : Integer[-1];
          if (n.sign) {
              return Integer[0];
          }
          if (!n.isSmall) throw new Error("The exponent " + n.toString() + " is too large.");
          if (this.isSmall) {
              if (isPrecise(value = Math.pow(a, b)))
                  return new SmallInteger(truncate(value));
          }
          x = this;
          y = Integer[1];
          while (true) {
              if (b & 1 === 1) {
                  y = y.times(x);
                  --b;
              }
              if (b === 0) break;
              b /= 2;
              x = x.square();
          }
          return y;
      };
      SmallInteger.prototype.pow = BigInteger.prototype.pow;
  
      NativeBigInt.prototype.pow = function (v) {
          var n = parseValue(v);
          var a = this.value, b = n.value;
          var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);
          if (b === _0) return Integer[1];
          if (a === _0) return Integer[0];
          if (a === _1) return Integer[1];
          if (a === BigInt(-1)) return n.isEven() ? Integer[1] : Integer[-1];
          if (n.isNegative()) return new NativeBigInt(_0);
          var x = this;
          var y = Integer[1];
          while (true) {
              if ((b & _1) === _1) {
                  y = y.times(x);
                  --b;
              }
              if (b === _0) break;
              b /= _2;
              x = x.square();
          }
          return y;
      }
  
      BigInteger.prototype.modPow = function (exp, mod) {
          exp = parseValue(exp);
          mod = parseValue(mod);
          if (mod.isZero()) throw new Error("Cannot take modPow with modulus 0");
          var r = Integer[1],
              base = this.mod(mod);
          if (exp.isNegative()) {
              exp = exp.multiply(Integer[-1]);
              base = base.modInv(mod);
          }
          while (exp.isPositive()) {
              if (base.isZero()) return Integer[0];
              if (exp.isOdd()) r = r.multiply(base).mod(mod);
              exp = exp.divide(2);
              base = base.square().mod(mod);
          }
          return r;
      };
      NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;
  
      function compareAbs(a, b) {
          if (a.length !== b.length) {
              return a.length > b.length ? 1 : -1;
          }
          for (var i = a.length - 1; i >= 0; i--) {
              if (a[i] !== b[i]) return a[i] > b[i] ? 1 : -1;
          }
          return 0;
      }
  
      BigInteger.prototype.compareAbs = function (v) {
          var n = parseValue(v),
              a = this.value,
              b = n.value;
          if (n.isSmall) return 1;
          return compareAbs(a, b);
      };
      SmallInteger.prototype.compareAbs = function (v) {
          var n = parseValue(v),
              a = Math.abs(this.value),
              b = n.value;
          if (n.isSmall) {
              b = Math.abs(b);
              return a === b ? 0 : a > b ? 1 : -1;
          }
          return -1;
      };
      NativeBigInt.prototype.compareAbs = function (v) {
          var a = this.value;
          var b = parseValue(v).value;
          a = a >= 0 ? a : -a;
          b = b >= 0 ? b : -b;
          return a === b ? 0 : a > b ? 1 : -1;
      }
  
      BigInteger.prototype.compare = function (v) {
          // See discussion about comparison with Infinity:
          // https://github.com/peterolson/BigInteger.js/issues/61
          if (v === Infinity) {
              return -1;
          }
          if (v === -Infinity) {
              return 1;
          }
  
          var n = parseValue(v),
              a = this.value,
              b = n.value;
          if (this.sign !== n.sign) {
              return n.sign ? 1 : -1;
          }
          if (n.isSmall) {
              return this.sign ? -1 : 1;
          }
          return compareAbs(a, b) * (this.sign ? -1 : 1);
      };
      BigInteger.prototype.compareTo = BigInteger.prototype.compare;
  
      SmallInteger.prototype.compare = function (v) {
          if (v === Infinity) {
              return -1;
          }
          if (v === -Infinity) {
              return 1;
          }
  
          var n = parseValue(v),
              a = this.value,
              b = n.value;
          if (n.isSmall) {
              return a == b ? 0 : a > b ? 1 : -1;
          }
          if (a < 0 !== n.sign) {
              return a < 0 ? -1 : 1;
          }
          return a < 0 ? 1 : -1;
      };
      SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
  
      NativeBigInt.prototype.compare = function (v) {
          if (v === Infinity) {
              return -1;
          }
          if (v === -Infinity) {
              return 1;
          }
          var a = this.value;
          var b = parseValue(v).value;
          return a === b ? 0 : a > b ? 1 : -1;
      }
      NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;
  
      BigInteger.prototype.equals = function (v) {
          return this.compare(v) === 0;
      };
      NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;
  
      BigInteger.prototype.notEquals = function (v) {
          return this.compare(v) !== 0;
      };
      NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;
  
      BigInteger.prototype.greater = function (v) {
          return this.compare(v) > 0;
      };
      NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;
  
      BigInteger.prototype.lesser = function (v) {
          return this.compare(v) < 0;
      };
      NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;
  
      BigInteger.prototype.greaterOrEquals = function (v) {
          return this.compare(v) >= 0;
      };
      NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;
  
      BigInteger.prototype.lesserOrEquals = function (v) {
          return this.compare(v) <= 0;
      };
      NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;
  
      BigInteger.prototype.isEven = function () {
          return (this.value[0] & 1) === 0;
      };
      SmallInteger.prototype.isEven = function () {
          return (this.value & 1) === 0;
      };
      NativeBigInt.prototype.isEven = function () {
          return (this.value & BigInt(1)) === BigInt(0);
      }
  
      BigInteger.prototype.isOdd = function () {
          return (this.value[0] & 1) === 1;
      };
      SmallInteger.prototype.isOdd = function () {
          return (this.value & 1) === 1;
      };
      NativeBigInt.prototype.isOdd = function () {
          return (this.value & BigInt(1)) === BigInt(1);
      }
  
      BigInteger.prototype.isPositive = function () {
          return !this.sign;
      };
      SmallInteger.prototype.isPositive = function () {
          return this.value > 0;
      };
      NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;
  
      BigInteger.prototype.isNegative = function () {
          return this.sign;
      };
      SmallInteger.prototype.isNegative = function () {
          return this.value < 0;
      };
      NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;
  
      BigInteger.prototype.isUnit = function () {
          return false;
      };
      SmallInteger.prototype.isUnit = function () {
          return Math.abs(this.value) === 1;
      };
      NativeBigInt.prototype.isUnit = function () {
          return this.abs().value === BigInt(1);
      }
  
      BigInteger.prototype.isZero = function () {
          return false;
      };
      SmallInteger.prototype.isZero = function () {
          return this.value === 0;
      };
      NativeBigInt.prototype.isZero = function () {
          return this.value === BigInt(0);
      }
  
      BigInteger.prototype.isDivisibleBy = function (v) {
          var n = parseValue(v);
          if (n.isZero()) return false;
          if (n.isUnit()) return true;
          if (n.compareAbs(2) === 0) return this.isEven();
          return this.mod(n).isZero();
      };
      NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;
  
      function isBasicPrime(v) {
          var n = v.abs();
          if (n.isUnit()) return false;
          if (n.equals(2) || n.equals(3) || n.equals(5)) return true;
          if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5)) return false;
          if (n.lesser(49)) return true;
          // we don't know if it's prime: let the other functions figure it out
      }
  
      function millerRabinTest(n, a) {
          var nPrev = n.prev(),
              b = nPrev,
              r = 0,
              d, t, i, x;
          while (b.isEven()) b = b.divide(2), r++;
          next: for (i = 0; i < a.length; i++) {
              if (n.lesser(a[i])) continue;
              x = bigInt(a[i]).modPow(b, n);
              if (x.isUnit() || x.equals(nPrev)) continue;
              for (d = r - 1; d != 0; d--) {
                  x = x.square().mod(n);
                  if (x.isUnit()) return false;
                  if (x.equals(nPrev)) continue next;
              }
              return false;
          }
          return true;
      }
  
      // Set "strict" to true to force GRH-supported lower bound of 2*log(N)^2
      BigInteger.prototype.isPrime = function (strict) {
          var isPrime = isBasicPrime(this);
          if (isPrime !== undefined) return isPrime;
          var n = this.abs();
          var bits = n.bitLength();
          if (bits <= 64)
              return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
          var logN = Math.log(2) * bits.toJSNumber();
          var t = Math.ceil((strict === true) ? (2 * Math.pow(logN, 2)) : logN);
          for (var a = [], i = 0; i < t; i++) {
              a.push(bigInt(i + 2));
          }
          return millerRabinTest(n, a);
      };
      NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;
  
      BigInteger.prototype.isProbablePrime = function (iterations, rng) {
          var isPrime = isBasicPrime(this);
          if (isPrime !== undefined) return isPrime;
          var n = this.abs();
          var t = iterations === undefined ? 5 : iterations;
          for (var a = [], i = 0; i < t; i++) {
              a.push(bigInt.randBetween(2, n.minus(2), rng));
          }
          return millerRabinTest(n, a);
      };
      NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;
  
      BigInteger.prototype.modInv = function (n) {
          var t = bigInt.zero, newT = bigInt.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
          while (!newR.isZero()) {
              q = r.divide(newR);
              lastT = t;
              lastR = r;
              t = newT;
              r = newR;
              newT = lastT.subtract(q.multiply(newT));
              newR = lastR.subtract(q.multiply(newR));
          }
          if (!r.isUnit()) throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
          if (t.compare(0) === -1) {
              t = t.add(n);
          }
          if (this.isNegative()) {
              return t.negate();
          }
          return t;
      };
  
      NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;
  
      BigInteger.prototype.next = function () {
          var value = this.value;
          if (this.sign) {
              return subtractSmall(value, 1, this.sign);
          }
          return new BigInteger(addSmall(value, 1), this.sign);
      };
      SmallInteger.prototype.next = function () {
          var value = this.value;
          if (value + 1 < MAX_INT) return new SmallInteger(value + 1);
          return new BigInteger(MAX_INT_ARR, false);
      };
      NativeBigInt.prototype.next = function () {
          return new NativeBigInt(this.value + BigInt(1));
      }
  
      BigInteger.prototype.prev = function () {
          var value = this.value;
          if (this.sign) {
              return new BigInteger(addSmall(value, 1), true);
          }
          return subtractSmall(value, 1, this.sign);
      };
      SmallInteger.prototype.prev = function () {
          var value = this.value;
          if (value - 1 > -MAX_INT) return new SmallInteger(value - 1);
          return new BigInteger(MAX_INT_ARR, true);
      };
      NativeBigInt.prototype.prev = function () {
          return new NativeBigInt(this.value - BigInt(1));
      }
  
      var powersOfTwo = [1];
      while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE) powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
      var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];
  
      function shift_isSmall(n) {
          return Math.abs(n) <= BASE;
      }
  
      BigInteger.prototype.shiftLeft = function (v) {
          var n = parseValue(v).toJSNumber();
          if (!shift_isSmall(n)) {
              throw new Error(String(n) + " is too large for shifting.");
          }
          if (n < 0) return this.shiftRight(-n);
          var result = this;
          if (result.isZero()) return result;
          while (n >= powers2Length) {
              result = result.multiply(highestPower2);
              n -= powers2Length - 1;
          }
          return result.multiply(powersOfTwo[n]);
      };
      NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;
  
      BigInteger.prototype.shiftRight = function (v) {
          var remQuo;
          var n = parseValue(v).toJSNumber();
          if (!shift_isSmall(n)) {
              throw new Error(String(n) + " is too large for shifting.");
          }
          if (n < 0) return this.shiftLeft(-n);
          var result = this;
          while (n >= powers2Length) {
              if (result.isZero() || (result.isNegative() && result.isUnit())) return result;
              remQuo = divModAny(result, highestPower2);
              result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
              n -= powers2Length - 1;
          }
          remQuo = divModAny(result, powersOfTwo[n]);
          return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
      };
      NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;
  
      function bitwise(x, y, fn) {
          y = parseValue(y);
          var xSign = x.isNegative(), ySign = y.isNegative();
          var xRem = xSign ? x.not() : x,
              yRem = ySign ? y.not() : y;
          var xDigit = 0, yDigit = 0;
          var xDivMod = null, yDivMod = null;
          var result = [];
          while (!xRem.isZero() || !yRem.isZero()) {
              xDivMod = divModAny(xRem, highestPower2);
              xDigit = xDivMod[1].toJSNumber();
              if (xSign) {
                  xDigit = highestPower2 - 1 - xDigit; // two's complement for negative numbers
              }
  
              yDivMod = divModAny(yRem, highestPower2);
              yDigit = yDivMod[1].toJSNumber();
              if (ySign) {
                  yDigit = highestPower2 - 1 - yDigit; // two's complement for negative numbers
              }
  
              xRem = xDivMod[0];
              yRem = yDivMod[0];
              result.push(fn(xDigit, yDigit));
          }
          var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt(-1) : bigInt(0);
          for (var i = result.length - 1; i >= 0; i -= 1) {
              sum = sum.multiply(highestPower2).add(bigInt(result[i]));
          }
          return sum;
      }
  
      BigInteger.prototype.not = function () {
          return this.negate().prev();
      };
      NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;
  
      BigInteger.prototype.and = function (n) {
          return bitwise(this, n, function (a, b) { return a & b; });
      };
      NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;
  
      BigInteger.prototype.or = function (n) {
          return bitwise(this, n, function (a, b) { return a | b; });
      };
      NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;
  
      BigInteger.prototype.xor = function (n) {
          return bitwise(this, n, function (a, b) { return a ^ b; });
      };
      NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;
  
      var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
      function roughLOB(n) { // get lowestOneBit (rough)
          // SmallInteger: return Min(lowestOneBit(n), 1 << 30)
          // BigInteger: return Min(lowestOneBit(n), 1 << 14) [BASE=1e7]
          var v = n.value,
              x = typeof v === "number" ? v | LOBMASK_I :
                  typeof v === "bigint" ? v | BigInt(LOBMASK_I) :
                      v[0] + v[1] * BASE | LOBMASK_BI;
          return x & -x;
      }
  
      function integerLogarithm(value, base) {
          if (base.compareTo(value) <= 0) {
              var tmp = integerLogarithm(value, base.square(base));
              var p = tmp.p;
              var e = tmp.e;
              var t = p.multiply(base);
              return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p: p, e: e * 2 };
          }
          return { p: bigInt(1), e: 0 };
      }
  
      BigInteger.prototype.bitLength = function () {
          var n = this;
          if (n.compareTo(bigInt(0)) < 0) {
              n = n.negate().subtract(bigInt(1));
          }
          if (n.compareTo(bigInt(0)) === 0) {
              return bigInt(0);
          }
          return bigInt(integerLogarithm(n, bigInt(2)).e).add(bigInt(1));
      }
      NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;
  
      function max(a, b) {
          a = parseValue(a);
          b = parseValue(b);
          return a.greater(b) ? a : b;
      }
      function min(a, b) {
          a = parseValue(a);
          b = parseValue(b);
          return a.lesser(b) ? a : b;
      }
      function gcd(a, b) {
          a = parseValue(a).abs();
          b = parseValue(b).abs();
          if (a.equals(b)) return a;
          if (a.isZero()) return b;
          if (b.isZero()) return a;
          var c = Integer[1], d, t;
          while (a.isEven() && b.isEven()) {
              d = min(roughLOB(a), roughLOB(b));
              a = a.divide(d);
              b = b.divide(d);
              c = c.multiply(d);
          }
          while (a.isEven()) {
              a = a.divide(roughLOB(a));
          }
          do {
              while (b.isEven()) {
                  b = b.divide(roughLOB(b));
              }
              if (a.greater(b)) {
                  t = b; b = a; a = t;
              }
              b = b.subtract(a);
          } while (!b.isZero());
          return c.isUnit() ? a : a.multiply(c);
      }
      function lcm(a, b) {
          a = parseValue(a).abs();
          b = parseValue(b).abs();
          return a.divide(gcd(a, b)).multiply(b);
      }
      function randBetween(a, b, rng) {
          a = parseValue(a);
          b = parseValue(b);
          var usedRNG = rng || Math.random;
          var low = min(a, b), high = max(a, b);
          var range = high.subtract(low).add(1);
          if (range.isSmall) return low.add(Math.floor(usedRNG() * range));
          var digits = toBase(range, BASE).value;
          var result = [], restricted = true;
          for (var i = 0; i < digits.length; i++) {
              var top = restricted ? digits[i] : BASE;
              var digit = truncate(usedRNG() * top);
              result.push(digit);
              if (digit < top) restricted = false;
          }
          return low.add(Integer.fromArray(result, BASE, false));
      }
  
      var parseBase = function (text, base, alphabet, caseSensitive) {
          alphabet = alphabet || DEFAULT_ALPHABET;
          text = String(text);
          if (!caseSensitive) {
              text = text.toLowerCase();
              alphabet = alphabet.toLowerCase();
          }
          var length = text.length;
          var i;
          var absBase = Math.abs(base);
          var alphabetValues = {};
          for (i = 0; i < alphabet.length; i++) {
              alphabetValues[alphabet[i]] = i;
          }
          for (i = 0; i < length; i++) {
              var c = text[i];
              if (c === "-") continue;
              if (c in alphabetValues) {
                  if (alphabetValues[c] >= absBase) {
                      if (c === "1" && absBase === 1) continue;
                      throw new Error(c + " is not a valid digit in base " + base + ".");
                  }
              }
          }
          base = parseValue(base);
          var digits = [];
          var isNegative = text[0] === "-";
          for (i = isNegative ? 1 : 0; i < text.length; i++) {
              var c = text[i];
              if (c in alphabetValues) digits.push(parseValue(alphabetValues[c]));
              else if (c === "<") {
                  var start = i;
                  do { i++; } while (text[i] !== ">" && i < text.length);
                  digits.push(parseValue(text.slice(start + 1, i)));
              }
              else throw new Error(c + " is not a valid character");
          }
          return parseBaseFromArray(digits, base, isNegative);
      };
  
      function parseBaseFromArray(digits, base, isNegative) {
          var val = Integer[0], pow = Integer[1], i;
          for (i = digits.length - 1; i >= 0; i--) {
              val = val.add(digits[i].times(pow));
              pow = pow.times(base);
          }
          return isNegative ? val.negate() : val;
      }
  
      function stringify(digit, alphabet) {
          alphabet = alphabet || DEFAULT_ALPHABET;
          if (digit < alphabet.length) {
              return alphabet[digit];
          }
          return "<" + digit + ">";
      }
  
      function toBase(n, base) {
          base = bigInt(base);
          if (base.isZero()) {
              if (n.isZero()) return { value: [0], isNegative: false };
              throw new Error("Cannot convert nonzero numbers to base 0.");
          }
          if (base.equals(-1)) {
              if (n.isZero()) return { value: [0], isNegative: false };
              if (n.isNegative())
                  return {
                      value: [].concat.apply([], Array.apply(null, Array(-n.toJSNumber()))
                          .map(Array.prototype.valueOf, [1, 0])
                      ),
                      isNegative: false
                  };
  
              var arr = Array.apply(null, Array(n.toJSNumber() - 1))
                  .map(Array.prototype.valueOf, [0, 1]);
              arr.unshift([1]);
              return {
                  value: [].concat.apply([], arr),
                  isNegative: false
              };
          }
  
          var neg = false;
          if (n.isNegative() && base.isPositive()) {
              neg = true;
              n = n.abs();
          }
          if (base.isUnit()) {
              if (n.isZero()) return { value: [0], isNegative: false };
  
              return {
                  value: Array.apply(null, Array(n.toJSNumber()))
                      .map(Number.prototype.valueOf, 1),
                  isNegative: neg
              };
          }
          var out = [];
          var left = n, divmod;
          while (left.isNegative() || left.compareAbs(base) >= 0) {
              divmod = left.divmod(base);
              left = divmod.quotient;
              var digit = divmod.remainder;
              if (digit.isNegative()) {
                  digit = base.minus(digit).abs();
                  left = left.next();
              }
              out.push(digit.toJSNumber());
          }
          out.push(left.toJSNumber());
          return { value: out.reverse(), isNegative: neg };
      }
  
      function toBaseString(n, base, alphabet) {
          var arr = toBase(n, base);
          return (arr.isNegative ? "-" : "") + arr.value.map(function (x) {
              return stringify(x, alphabet);
          }).join('');
      }
  
      BigInteger.prototype.toArray = function (radix) {
          return toBase(this, radix);
      };
  
      SmallInteger.prototype.toArray = function (radix) {
          return toBase(this, radix);
      };
  
      NativeBigInt.prototype.toArray = function (radix) {
          return toBase(this, radix);
      };
  
      BigInteger.prototype.toString = function (radix, alphabet) {
          if (radix === undefined) radix = 10;
          if (radix !== 10) return toBaseString(this, radix, alphabet);
          var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
          while (--l >= 0) {
              digit = String(v[l]);
              str += zeros.slice(digit.length) + digit;
          }
          var sign = this.sign ? "-" : "";
          return sign + str;
      };
  
      SmallInteger.prototype.toString = function (radix, alphabet) {
          if (radix === undefined) radix = 10;
          if (radix != 10) return toBaseString(this, radix, alphabet);
          return String(this.value);
      };
  
      NativeBigInt.prototype.toString = SmallInteger.prototype.toString;
  
      NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function () { return this.toString(); }
  
      BigInteger.prototype.valueOf = function () {
          return parseInt(this.toString(), 10);
      };
      BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
  
      SmallInteger.prototype.valueOf = function () {
          return this.value;
      };
      SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
      NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function () {
          return parseInt(this.toString(), 10);
      }
  
      function parseStringValue(v) {
          if (isPrecise(+v)) {
              var x = +v;
              if (x === truncate(x))
                  return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);
              throw new Error("Invalid integer: " + v);
          }
          var sign = v[0] === "-";
          if (sign) v = v.slice(1);
          var split = v.split(/e/i);
          if (split.length > 2) throw new Error("Invalid integer: " + split.join("e"));
          if (split.length === 2) {
              var exp = split[1];
              if (exp[0] === "+") exp = exp.slice(1);
              exp = +exp;
              if (exp !== truncate(exp) || !isPrecise(exp)) throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
              var text = split[0];
              var decimalPlace = text.indexOf(".");
              if (decimalPlace >= 0) {
                  exp -= text.length - decimalPlace - 1;
                  text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
              }
              if (exp < 0) throw new Error("Cannot include negative exponent part for integers");
              text += (new Array(exp + 1)).join("0");
              v = text;
          }
          var isValid = /^([0-9][0-9]*)$/.test(v);
          if (!isValid) throw new Error("Invalid integer: " + v);
          if (supportsNativeBigInt) {
              return new NativeBigInt(BigInt(sign ? "-" + v : v));
          }
          var r = [], max = v.length, l = LOG_BASE, min = max - l;
          while (max > 0) {
              r.push(+v.slice(min, max));
              min -= l;
              if (min < 0) min = 0;
              max -= l;
          }
          trim(r);
          return new BigInteger(r, sign);
      }
  
      function parseNumberValue(v) {
          if (supportsNativeBigInt) {
              return new NativeBigInt(BigInt(v));
          }
          if (isPrecise(v)) {
              if (v !== truncate(v)) throw new Error(v + " is not an integer.");
              return new SmallInteger(v);
          }
          return parseStringValue(v.toString());
      }
  
      function parseValue(v) {
          if (typeof v === "number") {
              return parseNumberValue(v);
          }
          if (typeof v === "string") {
              return parseStringValue(v);
          }
          if (typeof v === "bigint") {
              return new NativeBigInt(v);
          }
          return v;
      }
      // Pre-define numbers in range [-999,999]
      for (var i = 0; i < 1000; i++) {
          Integer[i] = parseValue(i);
          if (i > 0) Integer[-i] = parseValue(-i);
      }
      // Backwards compatibility
      Integer.one = Integer[1];
      Integer.zero = Integer[0];
      Integer.minusOne = Integer[-1];
      Integer.max = max;
      Integer.min = min;
      Integer.gcd = gcd;
      Integer.lcm = lcm;
      Integer.isInstance = function (x) { return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt; };
      Integer.randBetween = randBetween;
  
      Integer.fromArray = function (digits, base, isNegative) {
          return parseBaseFromArray(digits.map(parseValue), parseValue(base || 10), isNegative);
      };
  
      return Integer;
  })();
  
  // Node.js check
  if ( true && module.hasOwnProperty("exports")) {
      module.exports = bigInt;
  }
  
  //amd check
  if (typeof define === "function" && define.amd) {
      define( function () {
          return bigInt;
      });
  }
  
  
  /***/ }),
  
  /***/ 747:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  // adapted from http://code.google.com/p/plist/source/browse/trunk/src/com/dd/plist/BinaryPropertyListParser.java
  
  const fs = __nccwpck_require__(5747);
  const bigInt = __nccwpck_require__(575);
  const debug = false;
  
  exports.nI = 100 * 1000 * 1000; // 100Meg
  exports.m0 = 32768;
  
  // EPOCH = new SimpleDateFormat("yyyy MM dd zzz").parse("2001 01 01 GMT").getTime();
  // ...but that's annoying in a static initializer because it can throw exceptions, ick.
  // So we just hardcode the correct value.
  const EPOCH = 978307200000;
  
  // UID object definition
  const UID = __webpack_unused_export__ = function(id) {
    this.UID = id;
  };
  
  const parseFile = __webpack_unused_export__ = function (fileNameOrBuffer, callback) {
    return new Promise(function (resolve, reject) {
      function tryParseBuffer(buffer) {
        let err = null;
        let result;
        try {
          result = parseBuffer(buffer);
          resolve(result);
        } catch (ex) {
          err = ex;
          reject(err);
        } finally {
          if (callback) callback(err, result);
        }
      }
  
      if (Buffer.isBuffer(fileNameOrBuffer)) {
        return tryParseBuffer(fileNameOrBuffer);
      }
      fs.readFile(fileNameOrBuffer, function (err, data) {
        if (err) {
          reject(err);
          return callback(err);
        }
        tryParseBuffer(data);
      });
    });
  };
  
  const parseBuffer = exports.yY = function (buffer) {
    // check header
    const header = buffer.slice(0, 'bplist'.length).toString('utf8');
    if (header !== 'bplist') {
      throw new Error("Invalid binary plist. Expected 'bplist' at offset 0.");
    }
  
    // Handle trailer, last 32 bytes of the file
    const trailer = buffer.slice(buffer.length - 32, buffer.length);
    // 6 null bytes (index 0 to 5)
    const offsetSize = trailer.readUInt8(6);
    if (debug) {
      console.log("offsetSize: " + offsetSize);
    }
    const objectRefSize = trailer.readUInt8(7);
    if (debug) {
      console.log("objectRefSize: " + objectRefSize);
    }
    const numObjects = readUInt64BE(trailer, 8);
    if (debug) {
      console.log("numObjects: " + numObjects);
    }
    const topObject = readUInt64BE(trailer, 16);
    if (debug) {
      console.log("topObject: " + topObject);
    }
    const offsetTableOffset = readUInt64BE(trailer, 24);
    if (debug) {
      console.log("offsetTableOffset: " + offsetTableOffset);
    }
  
    if (numObjects > exports.m0) {
      throw new Error("maxObjectCount exceeded");
    }
  
    // Handle offset table
    const offsetTable = [];
  
    for (let i = 0; i < numObjects; i++) {
      const offsetBytes = buffer.slice(offsetTableOffset + i * offsetSize, offsetTableOffset + (i + 1) * offsetSize);
      offsetTable[i] = readUInt(offsetBytes, 0);
      if (debug) {
        console.log("Offset for Object #" + i + " is " + offsetTable[i] + " [" + offsetTable[i].toString(16) + "]");
      }
    }
  
    // Parses an object inside the currently parsed binary property list.
    // For the format specification check
    // <a href="http://www.opensource.apple.com/source/CF/CF-635/CFBinaryPList.c">
    // Apple's binary property list parser implementation</a>.
    function parseObject(tableOffset) {
      const offset = offsetTable[tableOffset];
      const type = buffer[offset];
      const objType = (type & 0xF0) >> 4; //First  4 bits
      const objInfo = (type & 0x0F);      //Second 4 bits
      switch (objType) {
      case 0x0:
        return parseSimple();
      case 0x1:
        return parseInteger();
      case 0x8:
        return parseUID();
      case 0x2:
        return parseReal();
      case 0x3:
        return parseDate();
      case 0x4:
        return parseData();
      case 0x5: // ASCII
        return parsePlistString();
      case 0x6: // UTF-16
        return parsePlistString(true);
      case 0xA:
        return parseArray();
      case 0xD:
        return parseDictionary();
      default:
        throw new Error("Unhandled type 0x" + objType.toString(16));
      }
  
      function parseSimple() {
        //Simple
        switch (objInfo) {
        case 0x0: // null
          return null;
        case 0x8: // false
          return false;
        case 0x9: // true
          return true;
        case 0xF: // filler byte
          return null;
        default:
          throw new Error("Unhandled simple type 0x" + objType.toString(16));
        }
      }
  
      function bufferToHexString(buffer) {
        let str = '';
        let i;
        for (i = 0; i < buffer.length; i++) {
          if (buffer[i] != 0x00) {
            break;
          }
        }
        for (; i < buffer.length; i++) {
          const part = '00' + buffer[i].toString(16);
          str += part.substr(part.length - 2);
        }
        return str;
      }
  
      function parseInteger() {
        const length = Math.pow(2, objInfo);
  
        if (objInfo == 0x4) {
          const data = buffer.slice(offset + 1, offset + 1 + length);
          const str = bufferToHexString(data);
          return bigInt(str, 16);
        }
        if (objInfo == 0x3) {
          return buffer.readInt32BE(offset + 1);
        }
        if (length < exports.nI) {
          return readUInt(buffer.slice(offset + 1, offset + 1 + length));
        }
        throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.nI + " are available.");
      }
  
      function parseUID() {
        const length = objInfo + 1;
        if (length < exports.nI) {
          return new UID(readUInt(buffer.slice(offset + 1, offset + 1 + length)));
        }
        throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.nI + " are available.");
      }
  
      function parseReal() {
        const length = Math.pow(2, objInfo);
        if (length < exports.nI) {
          const realBuffer = buffer.slice(offset + 1, offset + 1 + length);
          if (length === 4) {
            return realBuffer.readFloatBE(0);
          }
          if (length === 8) {
            return realBuffer.readDoubleBE(0);
          }
        } else {
          throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.nI + " are available.");
        }
      }
  
      function parseDate() {
        if (objInfo != 0x3) {
          console.error("Unknown date type :" + objInfo + ". Parsing anyway...");
        }
        const dateBuffer = buffer.slice(offset + 1, offset + 9);
        return new Date(EPOCH + (1000 * dateBuffer.readDoubleBE(0)));
      }
  
      function parseData() {
        let dataoffset = 1;
        let length = objInfo;
        if (objInfo == 0xF) {
          const int_type = buffer[offset + 1];
          const intType = (int_type & 0xF0) / 0x10;
          if (intType != 0x1) {
            console.error("0x4: UNEXPECTED LENGTH-INT TYPE! " + intType);
          }
          const intInfo = int_type & 0x0F;
          const intLength = Math.pow(2, intInfo);
          dataoffset = 2 + intLength;
          if (intLength < 3) {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          } else {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          }
        }
        if (length < exports.nI) {
          return buffer.slice(offset + dataoffset, offset + dataoffset + length);
        }
        throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.nI + " are available.");
      }
  
      function parsePlistString (isUtf16) {
        isUtf16 = isUtf16 || 0;
        let enc = "utf8";
        let length = objInfo;
        let stroffset = 1;
        if (objInfo == 0xF) {
          const int_type = buffer[offset + 1];
          const intType = (int_type & 0xF0) / 0x10;
          if (intType != 0x1) {
            console.err("UNEXPECTED LENGTH-INT TYPE! " + intType);
          }
          const intInfo = int_type & 0x0F;
          const intLength = Math.pow(2, intInfo);
          stroffset = 2 + intLength;
          if (intLength < 3) {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          } else {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          }
        }
        // length is String length -> to get byte length multiply by 2, as 1 character takes 2 bytes in UTF-16
        length *= (isUtf16 + 1);
        if (length < exports.nI) {
          let plistString = Buffer.from(buffer.slice(offset + stroffset, offset + stroffset + length));
          if (isUtf16) {
            plistString = swapBytes(plistString);
            enc = "ucs2";
          }
          return plistString.toString(enc);
        }
        throw new Error("To little heap space available! Wanted to read " + length + " bytes, but only " + exports.nI + " are available.");
      }
  
      function parseArray() {
        let length = objInfo;
        let arrayoffset = 1;
        if (objInfo == 0xF) {
          const int_type = buffer[offset + 1];
          const intType = (int_type & 0xF0) / 0x10;
          if (intType != 0x1) {
            console.error("0xa: UNEXPECTED LENGTH-INT TYPE! " + intType);
          }
          const intInfo = int_type & 0x0F;
          const intLength = Math.pow(2, intInfo);
          arrayoffset = 2 + intLength;
          if (intLength < 3) {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          } else {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          }
        }
        if (length * objectRefSize > exports.nI) {
          throw new Error("To little heap space available!");
        }
        const array = [];
        for (let i = 0; i < length; i++) {
          const objRef = readUInt(buffer.slice(offset + arrayoffset + i * objectRefSize, offset + arrayoffset + (i + 1) * objectRefSize));
          array[i] = parseObject(objRef);
        }
        return array;
      }
  
      function parseDictionary() {
        let length = objInfo;
        let dictoffset = 1;
        if (objInfo == 0xF) {
          const int_type = buffer[offset + 1];
          const intType = (int_type & 0xF0) / 0x10;
          if (intType != 0x1) {
            console.error("0xD: UNEXPECTED LENGTH-INT TYPE! " + intType);
          }
          const intInfo = int_type & 0x0F;
          const intLength = Math.pow(2, intInfo);
          dictoffset = 2 + intLength;
          if (intLength < 3) {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          } else {
            length = readUInt(buffer.slice(offset + 2, offset + 2 + intLength));
          }
        }
        if (length * 2 * objectRefSize > exports.nI) {
          throw new Error("To little heap space available!");
        }
        if (debug) {
          console.log("Parsing dictionary #" + tableOffset);
        }
        const dict = {};
        for (let i = 0; i < length; i++) {
          const keyRef = readUInt(buffer.slice(offset + dictoffset + i * objectRefSize, offset + dictoffset + (i + 1) * objectRefSize));
          const valRef = readUInt(buffer.slice(offset + dictoffset + (length * objectRefSize) + i * objectRefSize, offset + dictoffset + (length * objectRefSize) + (i + 1) * objectRefSize));
          const key = parseObject(keyRef);
          const val = parseObject(valRef);
          if (debug) {
            console.log("  DICT #" + tableOffset + ": Mapped " + key + " to " + val);
          }
          dict[key] = val;
        }
        return dict;
      }
    }
  
    return [ parseObject(topObject) ];
  };
  
  function readUInt(buffer, start) {
    start = start || 0;
  
    let l = 0;
    for (let i = start; i < buffer.length; i++) {
      l <<= 8;
      l |= buffer[i] & 0xFF;
    }
    return l;
  }
  
  // we're just going to toss the high order bits because javascript doesn't have 64-bit ints
  function readUInt64BE(buffer, start) {
    const data = buffer.slice(start, start + 8);
    return data.readUInt32BE(4, 8);
  }
  
  function swapBytes(buffer) {
    const len = buffer.length;
    for (let i = 0; i < len; i += 2) {
      const a = buffer[i];
      buffer[i] = buffer[i+1];
      buffer[i+1] = a;
    }
    return buffer;
  }
  
  
  /***/ }),
  
  /***/ 6542:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var Buffer = __nccwpck_require__(4293).Buffer;
  
  var CRC_TABLE = [
    0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419,
    0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4,
    0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07,
    0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de,
    0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856,
    0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9,
    0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4,
    0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b,
    0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3,
    0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a,
    0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599,
    0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924,
    0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190,
    0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f,
    0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e,
    0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01,
    0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed,
    0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950,
    0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3,
    0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2,
    0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a,
    0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5,
    0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010,
    0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f,
    0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17,
    0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6,
    0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615,
    0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8,
    0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344,
    0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb,
    0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a,
    0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5,
    0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1,
    0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c,
    0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef,
    0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236,
    0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe,
    0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31,
    0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c,
    0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713,
    0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b,
    0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242,
    0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1,
    0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c,
    0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278,
    0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7,
    0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66,
    0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9,
    0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605,
    0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8,
    0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b,
    0x2d02ef8d
  ];
  
  if (typeof Int32Array !== 'undefined') {
    CRC_TABLE = new Int32Array(CRC_TABLE);
  }
  
  function ensureBuffer(input) {
    if (Buffer.isBuffer(input)) {
      return input;
    }
  
    var hasNewBufferAPI =
        typeof Buffer.alloc === "function" &&
        typeof Buffer.from === "function";
  
    if (typeof input === "number") {
      return hasNewBufferAPI ? Buffer.alloc(input) : new Buffer(input);
    }
    else if (typeof input === "string") {
      return hasNewBufferAPI ? Buffer.from(input) : new Buffer(input);
    }
    else {
      throw new Error("input must be buffer, number, or string, received " +
                      typeof input);
    }
  }
  
  function bufferizeInt(num) {
    var tmp = ensureBuffer(4);
    tmp.writeInt32BE(num, 0);
    return tmp;
  }
  
  function _crc32(buf, previous) {
    buf = ensureBuffer(buf);
    if (Buffer.isBuffer(previous)) {
      previous = previous.readUInt32BE(0);
    }
    var crc = ~~previous ^ -1;
    for (var n = 0; n < buf.length; n++) {
      crc = CRC_TABLE[(crc ^ buf[n]) & 0xff] ^ (crc >>> 8);
    }
    return (crc ^ -1);
  }
  
  function crc32() {
    return bufferizeInt(_crc32.apply(null, arguments));
  }
  crc32.signed = function () {
    return _crc32.apply(null, arguments);
  };
  crc32.unsigned = function () {
    return _crc32.apply(null, arguments) >>> 0;
  };
  
  module.exports = crc32;
  
  
  /***/ }),
  
  /***/ 5728:
  /***/ ((module) => {
  
  /*!
   *  Copyright 2008 Fair Oaks Labs, Inc.
   *  All rights reserved.
   */
  
  // Utility object:  Encode/Decode C-style binary primitives to/from octet arrays
  function BufferPack() {
    // Module-level (private) variables
    var el,  bBE = false, m = this;
  
    // Raw byte arrays
    m._DeArray = function (a, p, l) {
      return [a.slice(p,p+l)];
    };
    m._EnArray = function (a, p, l, v) {
      for (var i = 0; i < l; a[p+i] = v[i]?v[i]:0, i++);
    };
  
    // ASCII characters
    m._DeChar = function (a, p) {
      return String.fromCharCode(a[p]);
    };
    m._EnChar = function (a, p, v) {
      a[p] = v.charCodeAt(0);
    };
  
    // Little-endian (un)signed N-byte integers
    m._DeInt = function (a, p) {
      var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, rv, i, f;
      for (rv = 0, i = lsb, f = 1; i != stop; rv+=(a[p+i]*f), i+=nsb, f*=256);
      if (el.bSigned && (rv & Math.pow(2, el.len*8-1))) {
        rv -= Math.pow(2, el.len*8);
      }
      return rv;
    };
    m._EnInt = function (a, p, v) {
      var lsb = bBE?(el.len-1):0, nsb = bBE?-1:1, stop = lsb+nsb*el.len, i;
      v = (v<el.min)?el.min:(v>el.max)?el.max:v;
      for (i = lsb; i != stop; a[p+i]=v&0xff, i+=nsb, v>>=8);
    };
  
    // ASCII character strings
    m._DeString = function (a, p, l) {
      for (var rv = new Array(l), i = 0; i < l; rv[i] = String.fromCharCode(a[p+i]), i++);
      return rv.join('');
    };
    m._EnString = function (a, p, l, v) {
      for (var t, i = 0; i < l; a[p+i] = (t=v.charCodeAt(i))?t:0, i++);
    };
  
    // ASCII character strings null terminated
    m._DeNullString = function (a, p, l, v) {
      var str = m._DeString(a, p, l, v);
      return str.substring(0, str.length - 1);
    };
  
    // Little-endian N-bit IEEE 754 floating point
    m._De754 = function (a, p) {
      var s, e, m, i, d, nBits, mLen, eLen, eBias, eMax;
      mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;
  
      i = bBE?0:(el.len-1); d = bBE?1:-1; s = a[p+i]; i+=d; nBits = -7;
      for (e = s&((1<<(-nBits))-1), s>>=(-nBits), nBits += eLen; nBits > 0; e=e*256+a[p+i], i+=d, nBits-=8);
      for (m = e&((1<<(-nBits))-1), e>>=(-nBits), nBits += mLen; nBits > 0; m=m*256+a[p+i], i+=d, nBits-=8);
  
      switch (e) {
      case 0:
        // Zero, or denormalized number
        e = 1-eBias;
        break;
      case eMax:
        // NaN, or +/-Infinity
        return m?NaN:((s?-1:1)*Infinity);
      default:
        // Normalized number
        m = m + Math.pow(2, mLen);
        e = e - eBias;
        break;
      }
      return (s?-1:1) * m * Math.pow(2, e-mLen);
    };
    m._En754 = function (a, p, v) {
      var s, e, m, i, d, c, mLen, eLen, eBias, eMax;
      mLen = el.mLen, eLen = el.len*8-el.mLen-1, eMax = (1<<eLen)-1, eBias = eMax>>1;
  
      s = v<0?1:0;
      v = Math.abs(v);
      if (isNaN(v) || (v == Infinity)) {
        m = isNaN(v)?1:0;
        e = eMax;
      } else {
        e = Math.floor(Math.log(v)/Math.LN2);			// Calculate log2 of the value
  
        if (v*(c = Math.pow(2, -e)) < 1) {
          e--; c*=2;						// Math.log() isn't 100% reliable
        }
  
        // Round by adding 1/2 the significand's LSD
        if (e+eBias >= 1) {
          v += el.rt/c;                                           // Normalized:  mLen significand digits
        } else {
          v += el.rt*Math.pow(2, 1-eBias);                        // Denormalized:  <= mLen significand digits
        }
  
        if (v*c >= 2) {
          e++; c/=2;						// Rounding can increment the exponent
        }
  
        if (e+eBias >= eMax) {
          // Overflow
          m = 0;
          e = eMax;
        } else if (e+eBias >= 1) {
          // Normalized - term order matters, as Math.pow(2, 52-e) and v*Math.pow(2, 52) can overflow
          m = (v*c-1)*Math.pow(2, mLen);
          e = e + eBias;
        } else {
          // Denormalized - also catches the '0' case, somewhat by chance
          m = v*Math.pow(2, eBias-1)*Math.pow(2, mLen);
          e = 0;
        }
      }
  
      for (i = bBE?(el.len-1):0, d=bBE?-1:1; mLen >= 8; a[p+i]=m&0xff, i+=d, m/=256, mLen-=8);
      for (e=(e<<mLen)|m, eLen+=mLen; eLen > 0; a[p+i]=e&0xff, i+=d, e/=256, eLen-=8);
      a[p+i-d] |= s*128;
    };
  
    // Class data
    m._sPattern = '(\\d+)?([AxcbBhHsSfdiIlL])(\\(([a-zA-Z0-9]+)\\))?';
    m._lenLut = {'A': 1, 'x': 1, 'c': 1, 'b': 1, 'B': 1, 'h': 2, 'H': 2, 's': 1,
                 'S': 1, 'f': 4, 'd': 8, 'i': 4, 'I': 4, 'l': 4, 'L': 4};
    m._elLut = {'A': {en: m._EnArray, de: m._DeArray},
                's': {en: m._EnString, de: m._DeString},
                'S': {en: m._EnString, de: m._DeNullString},
                'c': {en: m._EnChar, de: m._DeChar},
                'b': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: true, min: -Math.pow(2, 7), max: Math.pow(2, 7) - 1},
                'B': {en: m._EnInt, de: m._DeInt, len: 1, bSigned: false, min: 0, max: Math.pow(2, 8) - 1},
                'h': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: true, min: -Math.pow(2, 15), max: Math.pow(2, 15) - 1},
                'H': {en: m._EnInt, de: m._DeInt, len: 2, bSigned: false, min: 0, max: Math.pow(2, 16) - 1},
                'i': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
                'I': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
                'l': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: true, min: -Math.pow(2, 31), max: Math.pow(2, 31) - 1},
                'L': {en: m._EnInt, de: m._DeInt, len: 4, bSigned: false, min: 0, max: Math.pow(2, 32) - 1},
                'f': {en: m._En754, de: m._De754, len: 4, mLen: 23, rt: Math.pow(2, -24) - Math.pow(2, -77)},
                'd': {en: m._En754, de: m._De754, len: 8, mLen: 52, rt: 0}};
  
    // Unpack a series of n elements of size s from array a at offset p with fxn
    m._UnpackSeries = function (n, s, a, p) {
      for (var fxn = el.de, rv = [], i = 0; i < n; rv.push(fxn(a, p+i*s)), i++);
      return rv;
    };
  
    // Pack a series of n elements of size s from array v at offset i to array a at offset p with fxn
    m._PackSeries = function (n, s, a, p, v, i) {
      for (var fxn = el.en, o = 0; o < n; fxn(a, p+o*s, v[i+o]), o++);
    };
  
    m._zip = function (keys, values) {
      var result = {};
  
      for (var i = 0; i < keys.length; i++) {
        result[keys[i]] = values[i];
      }
  
      return result;
    }
  
    // Unpack the octet array a, beginning at offset p, according to the fmt string
    m.unpack = function (fmt, a, p) {
      // Set the private bBE flag based on the format string - assume big-endianness
      bBE = (fmt.charAt(0) != '<');
  
      p = p?p:0;
      var re = new RegExp(this._sPattern, 'g');
      var m;
      var n;
      var s;
      var rk = [];
      var rv = [];
      
      while (m = re.exec(fmt)) {
        n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
  
        if(m[2] === 'S') { // Null term string support
          n = 0; // Need to deal with empty  null term strings
          while(a[p + n] !== 0) {
            n++;
          }
          n++; // Add one for null byte
        }
  
        s = this._lenLut[m[2]];
  
        if ((p + n*s) > a.length) {
          return undefined;
        }
  
        switch (m[2]) {
        case 'A': case 's': case 'S':
          rv.push(this._elLut[m[2]].de(a, p, n));
          break;
        case 'c': case 'b': case 'B': case 'h': case 'H':
        case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':
          el = this._elLut[m[2]];
          rv.push(this._UnpackSeries(n, s, a, p));
          break;
        }
  
        rk.push(m[4]); // Push key on to array
  
        p += n*s;
      }   
  
      rv = Array.prototype.concat.apply([], rv)
  
      if(rk.indexOf(undefined) !== -1) {
        return rv;
      } else {
        return this._zip(rk, rv);
      }
    };
  
    // Pack the supplied values into the octet array a, beginning at offset p, according to the fmt string
    m.packTo = function (fmt, a, p, values) {
      // Set the private bBE flag based on the format string - assume big-endianness
      bBE = (fmt.charAt(0) != '<');
  
      var re = new RegExp(this._sPattern, 'g');
      var m;
      var n;
      var s;
      var i = 0;
      var j;
  
      while (m = re.exec(fmt)) {
        n = ((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1]);
  
        // Null term string support
        if(m[2] === 'S') {
          n = values[i].length + 1; // Add one for null byte
        }
  
        s = this._lenLut[m[2]];
  
        if ((p + n*s) > a.length) {
          return false;
        }
  
        switch (m[2]) {
        case 'A': case 's': case 'S':
          if ((i + 1) > values.length) { return false; }
          this._elLut[m[2]].en(a, p, n, values[i]);
          i += 1;
          break;
        case 'c': case 'b': case 'B': case 'h': case 'H':
        case 'i': case 'I': case 'l': case 'L': case 'f': case 'd':
          el = this._elLut[m[2]];
          if ((i + n) > values.length) { return false; }
          this._PackSeries(n, s, a, p, values, i);
          i += n;
          break;
        case 'x':
          for (j = 0; j < n; j++) { a[p+j] = 0; }
          break;
        }
        p += n*s;
      }
  
      return a;
    };
  
    // Pack the supplied values into a new octet array, according to the fmt string
    m.pack = function (fmt, values) {
      return this.packTo(fmt, new Buffer(this.calcLength(fmt, values)), 0, values);
    };
  
    // Determine the number of bytes represented by the format string
    m.calcLength = function (format, values) {
      var re = new RegExp(this._sPattern, 'g'), m, sum = 0, i = 0;
      while (m = re.exec(format)) {
        var n = (((m[1]==undefined)||(m[1]==''))?1:parseInt(m[1])) * this._lenLut[m[2]];
  
        if(m[2] === 'S') {
          n = values[i].length + 1; // Add one for null byte
        }
  
        sum += n;
        i++;
      }
      return sum;
    };
  };
  
  module.exports = new BufferPack();
  
  
  /***/ }),
  
  /***/ 1327:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  /*
   Copyright 2013-2014 Daniel Wirtz <dcode@dcode.io>
  
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
  
   http://www.apache.org/licenses/LICENSE-2.0
  
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
   */
  
  /**
   * @license bytebuffer.js (c) 2015 Daniel Wirtz <dcode@dcode.io>
   * Backing buffer / Accessor: node Buffer
   * Released under the Apache License, Version 2.0
   * see: https://github.com/dcodeIO/bytebuffer.js for details
   */
  module.exports = (function() {
      "use strict";
  
      var buffer = __nccwpck_require__(4293),
          Buffer = buffer["Buffer"],
          Long = __nccwpck_require__(8478),
          memcpy = null; try { memcpy = __nccwpck_require__(9449); } catch (e) {}
  
      /**
       * Constructs a new ByteBuffer.
       * @class The swiss army knife for binary data in JavaScript.
       * @exports ByteBuffer
       * @constructor
       * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @expose
       */
      var ByteBuffer = function(capacity, littleEndian, noAssert) {
          if (typeof capacity === 'undefined')
              capacity = ByteBuffer.DEFAULT_CAPACITY;
          if (typeof littleEndian === 'undefined')
              littleEndian = ByteBuffer.DEFAULT_ENDIAN;
          if (typeof noAssert === 'undefined')
              noAssert = ByteBuffer.DEFAULT_NOASSERT;
          if (!noAssert) {
              capacity = capacity | 0;
              if (capacity < 0)
                  throw RangeError("Illegal capacity");
              littleEndian = !!littleEndian;
              noAssert = !!noAssert;
          }
  
          /**
           * Backing node Buffer.
           * @type {!Buffer}
           * @expose
           */
          this.buffer = capacity === 0 ? EMPTY_BUFFER : new Buffer(capacity);
  
          /**
           * Absolute read/write offset.
           * @type {number}
           * @expose
           * @see ByteBuffer#flip
           * @see ByteBuffer#clear
           */
          this.offset = 0;
  
          /**
           * Marked offset.
           * @type {number}
           * @expose
           * @see ByteBuffer#mark
           * @see ByteBuffer#reset
           */
          this.markedOffset = -1;
  
          /**
           * Absolute limit of the contained data. Set to the backing buffer's capacity upon allocation.
           * @type {number}
           * @expose
           * @see ByteBuffer#flip
           * @see ByteBuffer#clear
           */
          this.limit = capacity;
  
          /**
           * Whether to use little endian byte order, defaults to `false` for big endian.
           * @type {boolean}
           * @expose
           */
          this.littleEndian = littleEndian;
  
          /**
           * Whether to skip assertions of offsets and values, defaults to `false`.
           * @type {boolean}
           * @expose
           */
          this.noAssert = noAssert;
      };
  
      /**
       * ByteBuffer version.
       * @type {string}
       * @const
       * @expose
       */
      ByteBuffer.VERSION = "5.0.1";
  
      /**
       * Little endian constant that can be used instead of its boolean value. Evaluates to `true`.
       * @type {boolean}
       * @const
       * @expose
       */
      ByteBuffer.LITTLE_ENDIAN = true;
  
      /**
       * Big endian constant that can be used instead of its boolean value. Evaluates to `false`.
       * @type {boolean}
       * @const
       * @expose
       */
      ByteBuffer.BIG_ENDIAN = false;
  
      /**
       * Default initial capacity of `16`.
       * @type {number}
       * @expose
       */
      ByteBuffer.DEFAULT_CAPACITY = 16;
  
      /**
       * Default endianess of `false` for big endian.
       * @type {boolean}
       * @expose
       */
      ByteBuffer.DEFAULT_ENDIAN = ByteBuffer.BIG_ENDIAN;
  
      /**
       * Default no assertions flag of `false`.
       * @type {boolean}
       * @expose
       */
      ByteBuffer.DEFAULT_NOASSERT = false;
  
      /**
       * A `Long` class for representing a 64-bit two's-complement integer value.
       * @type {!Long}
       * @const
       * @see https://npmjs.org/package/long
       * @expose
       */
      ByteBuffer.Long = Long;
  
      /**
       * @alias ByteBuffer.prototype
       * @inner
       */
      var ByteBufferPrototype = ByteBuffer.prototype;
  
      /**
       * An indicator used to reliably determine if an object is a ByteBuffer or not.
       * @type {boolean}
       * @const
       * @expose
       * @private
       */
      ByteBufferPrototype.__isByteBuffer__;
  
      Object.defineProperty(ByteBufferPrototype, "__isByteBuffer__", {
          value: true,
          enumerable: false,
          configurable: false
      });
  
      // helpers
  
      /**
       * @type {!Buffer}
       * @inner
       */
      var EMPTY_BUFFER = new Buffer(0);
  
      /**
       * String.fromCharCode reference for compile-time renaming.
       * @type {function(...number):string}
       * @inner
       */
      var stringFromCharCode = String.fromCharCode;
  
      /**
       * Creates a source function for a string.
       * @param {string} s String to read from
       * @returns {function():number|null} Source function returning the next char code respectively `null` if there are
       *  no more characters left.
       * @throws {TypeError} If the argument is invalid
       * @inner
       */
      function stringSource(s) {
          var i=0; return function() {
              return i < s.length ? s.charCodeAt(i++) : null;
          };
      }
  
      /**
       * Creates a destination function for a string.
       * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
       *  Returns the final string when called without arguments.
       * @inner
       */
      function stringDestination() {
          var cs = [], ps = []; return function() {
              if (arguments.length === 0)
                  return ps.join('')+stringFromCharCode.apply(String, cs);
              if (cs.length + arguments.length > 1024)
                  ps.push(stringFromCharCode.apply(String, cs)),
                      cs.length = 0;
              Array.prototype.push.apply(cs, arguments);
          };
      }
  
      /**
       * Gets the accessor type.
       * @returns {Function} `Buffer` under node.js, `Uint8Array` respectively `DataView` in the browser (classes)
       * @expose
       */
      ByteBuffer.accessor = function() {
          return Buffer;
      };
      /**
       * Allocates a new ByteBuffer backed by a buffer of the specified capacity.
       * @param {number=} capacity Initial capacity. Defaults to {@link ByteBuffer.DEFAULT_CAPACITY}.
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer}
       * @expose
       */
      ByteBuffer.allocate = function(capacity, littleEndian, noAssert) {
          return new ByteBuffer(capacity, littleEndian, noAssert);
      };
  
      /**
       * Concatenates multiple ByteBuffers into one.
       * @param {!Array.<!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string>} buffers Buffers to concatenate
       * @param {(string|boolean)=} encoding String encoding if `buffers` contains a string ("base64", "hex", "binary",
       *  defaults to "utf8")
       * @param {boolean=} littleEndian Whether to use little or big endian byte order for the resulting ByteBuffer. Defaults
       *  to {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values for the resulting ByteBuffer. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer} Concatenated ByteBuffer
       * @expose
       */
      ByteBuffer.concat = function(buffers, encoding, littleEndian, noAssert) {
          if (typeof encoding === 'boolean' || typeof encoding !== 'string') {
              noAssert = littleEndian;
              littleEndian = encoding;
              encoding = undefined;
          }
          var capacity = 0;
          for (var i=0, k=buffers.length, length; i<k; ++i) {
              if (!ByteBuffer.isByteBuffer(buffers[i]))
                  buffers[i] = ByteBuffer.wrap(buffers[i], encoding);
              length = buffers[i].limit - buffers[i].offset;
              if (length > 0) capacity += length;
          }
          if (capacity === 0)
              return new ByteBuffer(0, littleEndian, noAssert);
          var bb = new ByteBuffer(capacity, littleEndian, noAssert),
              bi;
          i=0; while (i<k) {
              bi = buffers[i++];
              length = bi.limit - bi.offset;
              if (length <= 0) continue;
              bi.buffer.copy(bb.buffer, bb.offset, bi.offset, bi.limit);
              bb.offset += length;
          }
          bb.limit = bb.offset;
          bb.offset = 0;
          return bb;
      };
  
      /**
       * Tests if the specified type is a ByteBuffer.
       * @param {*} bb ByteBuffer to test
       * @returns {boolean} `true` if it is a ByteBuffer, otherwise `false`
       * @expose
       */
      ByteBuffer.isByteBuffer = function(bb) {
          return (bb && bb["__isByteBuffer__"]) === true;
      };
      /**
       * Gets the backing buffer type.
       * @returns {Function} `Buffer` under node.js, `ArrayBuffer` in the browser (classes)
       * @expose
       */
      ByteBuffer.type = function() {
          return Buffer;
      };
      /**
       * Wraps a buffer or a string. Sets the allocated ByteBuffer's {@link ByteBuffer#offset} to `0` and its
       *  {@link ByteBuffer#limit} to the length of the wrapped data.
       * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string|!Array.<number>} buffer Anything that can be wrapped
       * @param {(string|boolean)=} encoding String encoding if `buffer` is a string ("base64", "hex", "binary", defaults to
       *  "utf8")
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer} A ByteBuffer wrapping `buffer`
       * @expose
       */
      ByteBuffer.wrap = function(buffer, encoding, littleEndian, noAssert) {
          if (typeof encoding !== 'string') {
              noAssert = littleEndian;
              littleEndian = encoding;
              encoding = undefined;
          }
          if (typeof buffer === 'string') {
              if (typeof encoding === 'undefined')
                  encoding = "utf8";
              switch (encoding) {
                  case "base64":
                      return ByteBuffer.fromBase64(buffer, littleEndian);
                  case "hex":
                      return ByteBuffer.fromHex(buffer, littleEndian);
                  case "binary":
                      return ByteBuffer.fromBinary(buffer, littleEndian);
                  case "utf8":
                      return ByteBuffer.fromUTF8(buffer, littleEndian);
                  case "debug":
                      return ByteBuffer.fromDebug(buffer, littleEndian);
                  default:
                      throw Error("Unsupported encoding: "+encoding);
              }
          }
          if (buffer === null || typeof buffer !== 'object')
              throw TypeError("Illegal buffer");
          var bb;
          if (ByteBuffer.isByteBuffer(buffer)) {
              bb = ByteBufferPrototype.clone.call(buffer);
              bb.markedOffset = -1;
              return bb;
          }
          var i = 0,
              k = 0,
              b;
          if (buffer instanceof Uint8Array) { // Extract bytes from Uint8Array
              b = new Buffer(buffer.length);
              if (memcpy) { // Fast
                  memcpy(b, 0, buffer.buffer, buffer.byteOffset, buffer.byteOffset + buffer.length);
              } else { // Slow
                  for (i=0, k=buffer.length; i<k; ++i)
                      b[i] = buffer[i];
              }
              buffer = b;
          } else if (buffer instanceof ArrayBuffer) { // Convert ArrayBuffer to Buffer
              b = new Buffer(buffer.byteLength);
              if (memcpy) { // Fast
                  memcpy(b, 0, buffer, 0, buffer.byteLength);
              } else { // Slow
                  buffer = new Uint8Array(buffer);
                  for (i=0, k=buffer.length; i<k; ++i) {
                      b[i] = buffer[i];
                  }
              }
              buffer = b;
          } else if (!(buffer instanceof Buffer)) { // Create from octets if it is an error, otherwise fail
              if (Object.prototype.toString.call(buffer) !== "[object Array]")
                  throw TypeError("Illegal buffer");
              buffer = new Buffer(buffer);
          }
          bb = new ByteBuffer(0, littleEndian, noAssert);
          if (buffer.length > 0) { // Avoid references to more than one EMPTY_BUFFER
              bb.buffer = buffer;
              bb.limit = buffer.length;
          }
          return bb;
      };
  
      /**
       * Writes the array as a bitset.
       * @param {Array<boolean>} value Array of booleans to write
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
       * @returns {!ByteBuffer}
       * @expose
       */
      ByteBufferPrototype.writeBitSet = function(value, offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
        if (!this.noAssert) {
          if (!(value instanceof Array))
            throw TypeError("Illegal BitSet: Not an array");
          if (typeof offset !== 'number' || offset % 1 !== 0)
              throw TypeError("Illegal offset: "+offset+" (not an integer)");
          offset >>>= 0;
          if (offset < 0 || offset + 0 > this.buffer.length)
              throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
        }
  
        var start = offset,
            bits = value.length,
            bytes = (bits >> 3),
            bit = 0,
            k;
  
        offset += this.writeVarint32(bits,offset);
  
        while(bytes--) {
          k = (!!value[bit++] & 1) |
              ((!!value[bit++] & 1) << 1) |
              ((!!value[bit++] & 1) << 2) |
              ((!!value[bit++] & 1) << 3) |
              ((!!value[bit++] & 1) << 4) |
              ((!!value[bit++] & 1) << 5) |
              ((!!value[bit++] & 1) << 6) |
              ((!!value[bit++] & 1) << 7);
          this.writeByte(k,offset++);
        }
  
        if(bit < bits) {
          var m = 0; k = 0;
          while(bit < bits) k = k | ((!!value[bit++] & 1) << (m++));
          this.writeByte(k,offset++);
        }
  
        if (relative) {
          this.offset = offset;
          return this;
        }
        return offset - start;
      }
  
      /**
       * Reads a BitSet as an array of booleans.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
       * @returns {Array<boolean>
       * @expose
       */
      ByteBufferPrototype.readBitSet = function(offset) {
        var relative = typeof offset === 'undefined';
        if (relative) offset = this.offset;
  
        var ret = this.readVarint32(offset),
            bits = ret.value,
            bytes = (bits >> 3),
            bit = 0,
            value = [],
            k;
  
        offset += ret.length;
  
        while(bytes--) {
          k = this.readByte(offset++);
          value[bit++] = !!(k & 0x01);
          value[bit++] = !!(k & 0x02);
          value[bit++] = !!(k & 0x04);
          value[bit++] = !!(k & 0x08);
          value[bit++] = !!(k & 0x10);
          value[bit++] = !!(k & 0x20);
          value[bit++] = !!(k & 0x40);
          value[bit++] = !!(k & 0x80);
        }
  
        if(bit < bits) {
          var m = 0;
          k = this.readByte(offset++);
          while(bit < bits) value[bit++] = !!((k >> (m++)) & 1);
        }
  
        if (relative) {
          this.offset = offset;
        }
        return value;
      }
      /**
       * Reads the specified number of bytes.
       * @param {number} length Number of bytes to read
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `length` if omitted.
       * @returns {!ByteBuffer}
       * @expose
       */
      ByteBufferPrototype.readBytes = function(length, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + length > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.length);
          }
          var slice = this.slice(offset, offset + length);
          if (relative) this.offset += length;
          return slice;
      };
  
      /**
       * Writes a payload of bytes. This is an alias of {@link ByteBuffer#append}.
       * @function
       * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string} source Data to write. If `source` is a ByteBuffer, its
       * offsets will be modified according to the performed read operation.
       * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeBytes = ByteBufferPrototype.append;
  
      // types/ints/int8
  
      /**
       * Writes an 8bit signed integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeInt8 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value |= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 1;
          var capacity0 = this.buffer.length;
          if (offset > capacity0)
              this.resize((capacity0 *= 2) > offset ? capacity0 : offset);
          offset -= 1;
          this.buffer[offset] = value;
          if (relative) this.offset += 1;
          return this;
      };
  
      /**
       * Writes an 8bit signed integer. This is an alias of {@link ByteBuffer#writeInt8}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeByte = ByteBufferPrototype.writeInt8;
  
      /**
       * Reads an 8bit signed integer.
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readInt8 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 1 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
          }
          var value = this.buffer[offset];
          if ((value & 0x80) === 0x80) value = -(0xFF - value + 1); // Cast to signed
          if (relative) this.offset += 1;
          return value;
      };
  
      /**
       * Reads an 8bit signed integer. This is an alias of {@link ByteBuffer#readInt8}.
       * @function
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readByte = ByteBufferPrototype.readInt8;
  
      /**
       * Writes an 8bit unsigned integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeUint8 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value >>>= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 1;
          var capacity1 = this.buffer.length;
          if (offset > capacity1)
              this.resize((capacity1 *= 2) > offset ? capacity1 : offset);
          offset -= 1;
          this.buffer[offset] = value;
          if (relative) this.offset += 1;
          return this;
      };
  
      /**
       * Writes an 8bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint8}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeUInt8 = ByteBufferPrototype.writeUint8;
  
      /**
       * Reads an 8bit unsigned integer.
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readUint8 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 1 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
          }
          var value = this.buffer[offset];
          if (relative) this.offset += 1;
          return value;
      };
  
      /**
       * Reads an 8bit unsigned integer. This is an alias of {@link ByteBuffer#readUint8}.
       * @function
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `1` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readUInt8 = ByteBufferPrototype.readUint8;
  
      // types/ints/int16
  
      /**
       * Writes a 16bit signed integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @throws {TypeError} If `offset` or `value` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.writeInt16 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value |= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 2;
          var capacity2 = this.buffer.length;
          if (offset > capacity2)
              this.resize((capacity2 *= 2) > offset ? capacity2 : offset);
          offset -= 2;
          if (this.littleEndian) {
              this.buffer[offset+1] = (value & 0xFF00) >>> 8;
              this.buffer[offset  ] =  value & 0x00FF;
          } else {
              this.buffer[offset]   = (value & 0xFF00) >>> 8;
              this.buffer[offset+1] =  value & 0x00FF;
          }
          if (relative) this.offset += 2;
          return this;
      };
  
      /**
       * Writes a 16bit signed integer. This is an alias of {@link ByteBuffer#writeInt16}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @throws {TypeError} If `offset` or `value` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.writeShort = ByteBufferPrototype.writeInt16;
  
      /**
       * Reads a 16bit signed integer.
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @returns {number} Value read
       * @throws {TypeError} If `offset` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.readInt16 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 2 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.length);
          }
          var value = 0;
          if (this.littleEndian) {
              value  = this.buffer[offset  ];
              value |= this.buffer[offset+1] << 8;
          } else {
              value  = this.buffer[offset  ] << 8;
              value |= this.buffer[offset+1];
          }
          if ((value & 0x8000) === 0x8000) value = -(0xFFFF - value + 1); // Cast to signed
          if (relative) this.offset += 2;
          return value;
      };
  
      /**
       * Reads a 16bit signed integer. This is an alias of {@link ByteBuffer#readInt16}.
       * @function
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @returns {number} Value read
       * @throws {TypeError} If `offset` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.readShort = ByteBufferPrototype.readInt16;
  
      /**
       * Writes a 16bit unsigned integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @throws {TypeError} If `offset` or `value` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.writeUint16 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value >>>= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 2;
          var capacity3 = this.buffer.length;
          if (offset > capacity3)
              this.resize((capacity3 *= 2) > offset ? capacity3 : offset);
          offset -= 2;
          if (this.littleEndian) {
              this.buffer[offset+1] = (value & 0xFF00) >>> 8;
              this.buffer[offset  ] =  value & 0x00FF;
          } else {
              this.buffer[offset]   = (value & 0xFF00) >>> 8;
              this.buffer[offset+1] =  value & 0x00FF;
          }
          if (relative) this.offset += 2;
          return this;
      };
  
      /**
       * Writes a 16bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint16}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @throws {TypeError} If `offset` or `value` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.writeUInt16 = ByteBufferPrototype.writeUint16;
  
      /**
       * Reads a 16bit unsigned integer.
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @returns {number} Value read
       * @throws {TypeError} If `offset` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.readUint16 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 2 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+2+") <= "+this.buffer.length);
          }
          var value = 0;
          if (this.littleEndian) {
              value  = this.buffer[offset  ];
              value |= this.buffer[offset+1] << 8;
          } else {
              value  = this.buffer[offset  ] << 8;
              value |= this.buffer[offset+1];
          }
          if (relative) this.offset += 2;
          return value;
      };
  
      /**
       * Reads a 16bit unsigned integer. This is an alias of {@link ByteBuffer#readUint16}.
       * @function
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `2` if omitted.
       * @returns {number} Value read
       * @throws {TypeError} If `offset` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @expose
       */
      ByteBufferPrototype.readUInt16 = ByteBufferPrototype.readUint16;
  
      // types/ints/int32
  
      /**
       * Writes a 32bit signed integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @expose
       */
      ByteBufferPrototype.writeInt32 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value |= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 4;
          var capacity4 = this.buffer.length;
          if (offset > capacity4)
              this.resize((capacity4 *= 2) > offset ? capacity4 : offset);
          offset -= 4;
          if (this.littleEndian) {
              this.buffer[offset+3] = (value >>> 24) & 0xFF;
              this.buffer[offset+2] = (value >>> 16) & 0xFF;
              this.buffer[offset+1] = (value >>>  8) & 0xFF;
              this.buffer[offset  ] =  value         & 0xFF;
          } else {
              this.buffer[offset  ] = (value >>> 24) & 0xFF;
              this.buffer[offset+1] = (value >>> 16) & 0xFF;
              this.buffer[offset+2] = (value >>>  8) & 0xFF;
              this.buffer[offset+3] =  value         & 0xFF;
          }
          if (relative) this.offset += 4;
          return this;
      };
  
      /**
       * Writes a 32bit signed integer. This is an alias of {@link ByteBuffer#writeInt32}.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @expose
       */
      ByteBufferPrototype.writeInt = ByteBufferPrototype.writeInt32;
  
      /**
       * Reads a 32bit signed integer.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readInt32 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 4 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.length);
          }
          var value = 0;
          if (this.littleEndian) {
              value  = this.buffer[offset+2] << 16;
              value |= this.buffer[offset+1] <<  8;
              value |= this.buffer[offset  ];
              value += this.buffer[offset+3] << 24 >>> 0;
          } else {
              value  = this.buffer[offset+1] << 16;
              value |= this.buffer[offset+2] <<  8;
              value |= this.buffer[offset+3];
              value += this.buffer[offset  ] << 24 >>> 0;
          }
          value |= 0; // Cast to signed
          if (relative) this.offset += 4;
          return value;
      };
  
      /**
       * Reads a 32bit signed integer. This is an alias of {@link ByteBuffer#readInt32}.
       * @param {number=} offset Offset to read from. Will use and advance {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readInt = ByteBufferPrototype.readInt32;
  
      /**
       * Writes a 32bit unsigned integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @expose
       */
      ByteBufferPrototype.writeUint32 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value >>>= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 4;
          var capacity5 = this.buffer.length;
          if (offset > capacity5)
              this.resize((capacity5 *= 2) > offset ? capacity5 : offset);
          offset -= 4;
          if (this.littleEndian) {
              this.buffer[offset+3] = (value >>> 24) & 0xFF;
              this.buffer[offset+2] = (value >>> 16) & 0xFF;
              this.buffer[offset+1] = (value >>>  8) & 0xFF;
              this.buffer[offset  ] =  value         & 0xFF;
          } else {
              this.buffer[offset  ] = (value >>> 24) & 0xFF;
              this.buffer[offset+1] = (value >>> 16) & 0xFF;
              this.buffer[offset+2] = (value >>>  8) & 0xFF;
              this.buffer[offset+3] =  value         & 0xFF;
          }
          if (relative) this.offset += 4;
          return this;
      };
  
      /**
       * Writes a 32bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint32}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @expose
       */
      ByteBufferPrototype.writeUInt32 = ByteBufferPrototype.writeUint32;
  
      /**
       * Reads a 32bit unsigned integer.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readUint32 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 4 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.length);
          }
          var value = 0;
          if (this.littleEndian) {
              value  = this.buffer[offset+2] << 16;
              value |= this.buffer[offset+1] <<  8;
              value |= this.buffer[offset  ];
              value += this.buffer[offset+3] << 24 >>> 0;
          } else {
              value  = this.buffer[offset+1] << 16;
              value |= this.buffer[offset+2] <<  8;
              value |= this.buffer[offset+3];
              value += this.buffer[offset  ] << 24 >>> 0;
          }
          if (relative) this.offset += 4;
          return value;
      };
  
      /**
       * Reads a 32bit unsigned integer. This is an alias of {@link ByteBuffer#readUint32}.
       * @function
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number} Value read
       * @expose
       */
      ByteBufferPrototype.readUInt32 = ByteBufferPrototype.readUint32;
  
      // types/ints/int64
  
      if (Long) {
  
          /**
           * Writes a 64bit signed integer.
           * @param {number|!Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!ByteBuffer} this
           * @expose
           */
          ByteBufferPrototype.writeInt64 = function(value, offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof value === 'number')
                      value = Long.fromNumber(value);
                  else if (typeof value === 'string')
                      value = Long.fromString(value);
                  else if (!(value && value instanceof Long))
                      throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 0 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
              }
              if (typeof value === 'number')
                  value = Long.fromNumber(value);
              else if (typeof value === 'string')
                  value = Long.fromString(value);
              offset += 8;
              var capacity6 = this.buffer.length;
              if (offset > capacity6)
                  this.resize((capacity6 *= 2) > offset ? capacity6 : offset);
              offset -= 8;
              var lo = value.low,
                  hi = value.high;
              if (this.littleEndian) {
                  this.buffer[offset+3] = (lo >>> 24) & 0xFF;
                  this.buffer[offset+2] = (lo >>> 16) & 0xFF;
                  this.buffer[offset+1] = (lo >>>  8) & 0xFF;
                  this.buffer[offset  ] =  lo         & 0xFF;
                  offset += 4;
                  this.buffer[offset+3] = (hi >>> 24) & 0xFF;
                  this.buffer[offset+2] = (hi >>> 16) & 0xFF;
                  this.buffer[offset+1] = (hi >>>  8) & 0xFF;
                  this.buffer[offset  ] =  hi         & 0xFF;
              } else {
                  this.buffer[offset  ] = (hi >>> 24) & 0xFF;
                  this.buffer[offset+1] = (hi >>> 16) & 0xFF;
                  this.buffer[offset+2] = (hi >>>  8) & 0xFF;
                  this.buffer[offset+3] =  hi         & 0xFF;
                  offset += 4;
                  this.buffer[offset  ] = (lo >>> 24) & 0xFF;
                  this.buffer[offset+1] = (lo >>> 16) & 0xFF;
                  this.buffer[offset+2] = (lo >>>  8) & 0xFF;
                  this.buffer[offset+3] =  lo         & 0xFF;
              }
              if (relative) this.offset += 8;
              return this;
          };
  
          /**
           * Writes a 64bit signed integer. This is an alias of {@link ByteBuffer#writeInt64}.
           * @param {number|!Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!ByteBuffer} this
           * @expose
           */
          ByteBufferPrototype.writeLong = ByteBufferPrototype.writeInt64;
  
          /**
           * Reads a 64bit signed integer.
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!Long}
           * @expose
           */
          ByteBufferPrototype.readInt64 = function(offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 8 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.length);
              }
              var lo = 0,
                  hi = 0;
              if (this.littleEndian) {
                  lo  = this.buffer[offset+2] << 16;
                  lo |= this.buffer[offset+1] <<  8;
                  lo |= this.buffer[offset  ];
                  lo += this.buffer[offset+3] << 24 >>> 0;
                  offset += 4;
                  hi  = this.buffer[offset+2] << 16;
                  hi |= this.buffer[offset+1] <<  8;
                  hi |= this.buffer[offset  ];
                  hi += this.buffer[offset+3] << 24 >>> 0;
              } else {
                  hi  = this.buffer[offset+1] << 16;
                  hi |= this.buffer[offset+2] <<  8;
                  hi |= this.buffer[offset+3];
                  hi += this.buffer[offset  ] << 24 >>> 0;
                  offset += 4;
                  lo  = this.buffer[offset+1] << 16;
                  lo |= this.buffer[offset+2] <<  8;
                  lo |= this.buffer[offset+3];
                  lo += this.buffer[offset  ] << 24 >>> 0;
              }
              var value = new Long(lo, hi, false);
              if (relative) this.offset += 8;
              return value;
          };
  
          /**
           * Reads a 64bit signed integer. This is an alias of {@link ByteBuffer#readInt64}.
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!Long}
           * @expose
           */
          ByteBufferPrototype.readLong = ByteBufferPrototype.readInt64;
  
          /**
           * Writes a 64bit unsigned integer.
           * @param {number|!Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!ByteBuffer} this
           * @expose
           */
          ByteBufferPrototype.writeUint64 = function(value, offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof value === 'number')
                      value = Long.fromNumber(value);
                  else if (typeof value === 'string')
                      value = Long.fromString(value);
                  else if (!(value && value instanceof Long))
                      throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 0 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
              }
              if (typeof value === 'number')
                  value = Long.fromNumber(value);
              else if (typeof value === 'string')
                  value = Long.fromString(value);
              offset += 8;
              var capacity7 = this.buffer.length;
              if (offset > capacity7)
                  this.resize((capacity7 *= 2) > offset ? capacity7 : offset);
              offset -= 8;
              var lo = value.low,
                  hi = value.high;
              if (this.littleEndian) {
                  this.buffer[offset+3] = (lo >>> 24) & 0xFF;
                  this.buffer[offset+2] = (lo >>> 16) & 0xFF;
                  this.buffer[offset+1] = (lo >>>  8) & 0xFF;
                  this.buffer[offset  ] =  lo         & 0xFF;
                  offset += 4;
                  this.buffer[offset+3] = (hi >>> 24) & 0xFF;
                  this.buffer[offset+2] = (hi >>> 16) & 0xFF;
                  this.buffer[offset+1] = (hi >>>  8) & 0xFF;
                  this.buffer[offset  ] =  hi         & 0xFF;
              } else {
                  this.buffer[offset  ] = (hi >>> 24) & 0xFF;
                  this.buffer[offset+1] = (hi >>> 16) & 0xFF;
                  this.buffer[offset+2] = (hi >>>  8) & 0xFF;
                  this.buffer[offset+3] =  hi         & 0xFF;
                  offset += 4;
                  this.buffer[offset  ] = (lo >>> 24) & 0xFF;
                  this.buffer[offset+1] = (lo >>> 16) & 0xFF;
                  this.buffer[offset+2] = (lo >>>  8) & 0xFF;
                  this.buffer[offset+3] =  lo         & 0xFF;
              }
              if (relative) this.offset += 8;
              return this;
          };
  
          /**
           * Writes a 64bit unsigned integer. This is an alias of {@link ByteBuffer#writeUint64}.
           * @function
           * @param {number|!Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!ByteBuffer} this
           * @expose
           */
          ByteBufferPrototype.writeUInt64 = ByteBufferPrototype.writeUint64;
  
          /**
           * Reads a 64bit unsigned integer.
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!Long}
           * @expose
           */
          ByteBufferPrototype.readUint64 = function(offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 8 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.length);
              }
              var lo = 0,
                  hi = 0;
              if (this.littleEndian) {
                  lo  = this.buffer[offset+2] << 16;
                  lo |= this.buffer[offset+1] <<  8;
                  lo |= this.buffer[offset  ];
                  lo += this.buffer[offset+3] << 24 >>> 0;
                  offset += 4;
                  hi  = this.buffer[offset+2] << 16;
                  hi |= this.buffer[offset+1] <<  8;
                  hi |= this.buffer[offset  ];
                  hi += this.buffer[offset+3] << 24 >>> 0;
              } else {
                  hi  = this.buffer[offset+1] << 16;
                  hi |= this.buffer[offset+2] <<  8;
                  hi |= this.buffer[offset+3];
                  hi += this.buffer[offset  ] << 24 >>> 0;
                  offset += 4;
                  lo  = this.buffer[offset+1] << 16;
                  lo |= this.buffer[offset+2] <<  8;
                  lo |= this.buffer[offset+3];
                  lo += this.buffer[offset  ] << 24 >>> 0;
              }
              var value = new Long(lo, hi, true);
              if (relative) this.offset += 8;
              return value;
          };
  
          /**
           * Reads a 64bit unsigned integer. This is an alias of {@link ByteBuffer#readUint64}.
           * @function
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
           * @returns {!Long}
           * @expose
           */
          ByteBufferPrototype.readUInt64 = ByteBufferPrototype.readUint64;
  
      } // Long
  
  
      // types/floats/float32
  
      /**
       * Writes a 32bit float.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeFloat32 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number')
                  throw TypeError("Illegal value: "+value+" (not a number)");
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 4;
          var capacity8 = this.buffer.length;
          if (offset > capacity8)
              this.resize((capacity8 *= 2) > offset ? capacity8 : offset);
          offset -= 4;
          this.littleEndian
              ? this.buffer.writeFloatLE(value, offset, true)
              : this.buffer.writeFloatBE(value, offset, true);
          if (relative) this.offset += 4;
          return this;
      };
  
      /**
       * Writes a 32bit float. This is an alias of {@link ByteBuffer#writeFloat32}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeFloat = ByteBufferPrototype.writeFloat32;
  
      /**
       * Reads a 32bit float.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number}
       * @expose
       */
      ByteBufferPrototype.readFloat32 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 4 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.length);
          }
          var value = this.littleEndian
              ? this.buffer.readFloatLE(offset, true)
              : this.buffer.readFloatBE(offset, true);
          if (relative) this.offset += 4;
          return value;
      };
  
      /**
       * Reads a 32bit float. This is an alias of {@link ByteBuffer#readFloat32}.
       * @function
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `4` if omitted.
       * @returns {number}
       * @expose
       */
      ByteBufferPrototype.readFloat = ByteBufferPrototype.readFloat32;
  
      // types/floats/float64
  
      /**
       * Writes a 64bit float.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeFloat64 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number')
                  throw TypeError("Illegal value: "+value+" (not a number)");
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          offset += 8;
          var capacity9 = this.buffer.length;
          if (offset > capacity9)
              this.resize((capacity9 *= 2) > offset ? capacity9 : offset);
          offset -= 8;
          this.littleEndian
              ? this.buffer.writeDoubleLE(value, offset, true)
              : this.buffer.writeDoubleBE(value, offset, true);
          if (relative) this.offset += 8;
          return this;
      };
  
      /**
       * Writes a 64bit float. This is an alias of {@link ByteBuffer#writeFloat64}.
       * @function
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.writeDouble = ByteBufferPrototype.writeFloat64;
  
      /**
       * Reads a 64bit float.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
       * @returns {number}
       * @expose
       */
      ByteBufferPrototype.readFloat64 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 8 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+8+") <= "+this.buffer.length);
          }
          var value = this.littleEndian
              ? this.buffer.readDoubleLE(offset, true)
              : this.buffer.readDoubleBE(offset, true);
          if (relative) this.offset += 8;
          return value;
      };
  
      /**
       * Reads a 64bit float. This is an alias of {@link ByteBuffer#readFloat64}.
       * @function
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by `8` if omitted.
       * @returns {number}
       * @expose
       */
      ByteBufferPrototype.readDouble = ByteBufferPrototype.readFloat64;
  
  
      // types/varints/varint32
  
      /**
       * Maximum number of bytes required to store a 32bit base 128 variable-length integer.
       * @type {number}
       * @const
       * @expose
       */
      ByteBuffer.MAX_VARINT32_BYTES = 5;
  
      /**
       * Calculates the actual number of bytes required to store a 32bit base 128 variable-length integer.
       * @param {number} value Value to encode
       * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT32_BYTES}
       * @expose
       */
      ByteBuffer.calculateVarint32 = function(value) {
          // ref: src/google/protobuf/io/coded_stream.cc
          value = value >>> 0;
               if (value < 1 << 7 ) return 1;
          else if (value < 1 << 14) return 2;
          else if (value < 1 << 21) return 3;
          else if (value < 1 << 28) return 4;
          else                      return 5;
      };
  
      /**
       * Zigzag encodes a signed 32bit integer so that it can be effectively used with varint encoding.
       * @param {number} n Signed 32bit integer
       * @returns {number} Unsigned zigzag encoded 32bit integer
       * @expose
       */
      ByteBuffer.zigZagEncode32 = function(n) {
          return (((n |= 0) << 1) ^ (n >> 31)) >>> 0; // ref: src/google/protobuf/wire_format_lite.h
      };
  
      /**
       * Decodes a zigzag encoded signed 32bit integer.
       * @param {number} n Unsigned zigzag encoded 32bit integer
       * @returns {number} Signed 32bit integer
       * @expose
       */
      ByteBuffer.zigZagDecode32 = function(n) {
          return ((n >>> 1) ^ -(n & 1)) | 0; // // ref: src/google/protobuf/wire_format_lite.h
      };
  
      /**
       * Writes a 32bit base 128 variable-length integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
       * @expose
       */
      ByteBufferPrototype.writeVarint32 = function(value, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value |= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          var size = ByteBuffer.calculateVarint32(value),
              b;
          offset += size;
          var capacity10 = this.buffer.length;
          if (offset > capacity10)
              this.resize((capacity10 *= 2) > offset ? capacity10 : offset);
          offset -= size;
          value >>>= 0;
          while (value >= 0x80) {
              b = (value & 0x7f) | 0x80;
              this.buffer[offset++] = b;
              value >>>= 7;
          }
          this.buffer[offset++] = value;
          if (relative) {
              this.offset = offset;
              return this;
          }
          return size;
      };
  
      /**
       * Writes a zig-zag encoded (signed) 32bit base 128 variable-length integer.
       * @param {number} value Value to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer|number} this if `offset` is omitted, else the actual number of bytes written
       * @expose
       */
      ByteBufferPrototype.writeVarint32ZigZag = function(value, offset) {
          return this.writeVarint32(ByteBuffer.zigZagEncode32(value), offset);
      };
  
      /**
       * Reads a 32bit base 128 variable-length integer.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
       *  and the actual number of bytes read.
       * @throws {Error} If it's not a valid varint. Has a property `truncated = true` if there is not enough data available
       *  to fully decode the varint.
       * @expose
       */
      ByteBufferPrototype.readVarint32 = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 1 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
          }
          var c = 0,
              value = 0 >>> 0,
              b;
          do {
              if (!this.noAssert && offset > this.limit) {
                  var err = Error("Truncated");
                  err['truncated'] = true;
                  throw err;
              }
              b = this.buffer[offset++];
              if (c < 5)
                  value |= (b & 0x7f) << (7*c);
              ++c;
          } while ((b & 0x80) !== 0);
          value |= 0;
          if (relative) {
              this.offset = offset;
              return value;
          }
          return {
              "value": value,
              "length": c
          };
      };
  
      /**
       * Reads a zig-zag encoded (signed) 32bit base 128 variable-length integer.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {number|!{value: number, length: number}} The value read if offset is omitted, else the value read
       *  and the actual number of bytes read.
       * @throws {Error} If it's not a valid varint
       * @expose
       */
      ByteBufferPrototype.readVarint32ZigZag = function(offset) {
          var val = this.readVarint32(offset);
          if (typeof val === 'object')
              val["value"] = ByteBuffer.zigZagDecode32(val["value"]);
          else
              val = ByteBuffer.zigZagDecode32(val);
          return val;
      };
  
      // types/varints/varint64
  
      if (Long) {
  
          /**
           * Maximum number of bytes required to store a 64bit base 128 variable-length integer.
           * @type {number}
           * @const
           * @expose
           */
          ByteBuffer.MAX_VARINT64_BYTES = 10;
  
          /**
           * Calculates the actual number of bytes required to store a 64bit base 128 variable-length integer.
           * @param {number|!Long} value Value to encode
           * @returns {number} Number of bytes required. Capped to {@link ByteBuffer.MAX_VARINT64_BYTES}
           * @expose
           */
          ByteBuffer.calculateVarint64 = function(value) {
              if (typeof value === 'number')
                  value = Long.fromNumber(value);
              else if (typeof value === 'string')
                  value = Long.fromString(value);
              // ref: src/google/protobuf/io/coded_stream.cc
              var part0 = value.toInt() >>> 0,
                  part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
                  part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
              if (part2 == 0) {
                  if (part1 == 0) {
                      if (part0 < 1 << 14)
                          return part0 < 1 << 7 ? 1 : 2;
                      else
                          return part0 < 1 << 21 ? 3 : 4;
                  } else {
                      if (part1 < 1 << 14)
                          return part1 < 1 << 7 ? 5 : 6;
                      else
                          return part1 < 1 << 21 ? 7 : 8;
                  }
              } else
                  return part2 < 1 << 7 ? 9 : 10;
          };
  
          /**
           * Zigzag encodes a signed 64bit integer so that it can be effectively used with varint encoding.
           * @param {number|!Long} value Signed long
           * @returns {!Long} Unsigned zigzag encoded long
           * @expose
           */
          ByteBuffer.zigZagEncode64 = function(value) {
              if (typeof value === 'number')
                  value = Long.fromNumber(value, false);
              else if (typeof value === 'string')
                  value = Long.fromString(value, false);
              else if (value.unsigned !== false) value = value.toSigned();
              // ref: src/google/protobuf/wire_format_lite.h
              return value.shiftLeft(1).xor(value.shiftRight(63)).toUnsigned();
          };
  
          /**
           * Decodes a zigzag encoded signed 64bit integer.
           * @param {!Long|number} value Unsigned zigzag encoded long or JavaScript number
           * @returns {!Long} Signed long
           * @expose
           */
          ByteBuffer.zigZagDecode64 = function(value) {
              if (typeof value === 'number')
                  value = Long.fromNumber(value, false);
              else if (typeof value === 'string')
                  value = Long.fromString(value, false);
              else if (value.unsigned !== false) value = value.toSigned();
              // ref: src/google/protobuf/wire_format_lite.h
              return value.shiftRightUnsigned(1).xor(value.and(Long.ONE).toSigned().negate()).toSigned();
          };
  
          /**
           * Writes a 64bit base 128 variable-length integer.
           * @param {number|Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
           *  written if omitted.
           * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
           * @expose
           */
          ByteBufferPrototype.writeVarint64 = function(value, offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof value === 'number')
                      value = Long.fromNumber(value);
                  else if (typeof value === 'string')
                      value = Long.fromString(value);
                  else if (!(value && value instanceof Long))
                      throw TypeError("Illegal value: "+value+" (not an integer or Long)");
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 0 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
              }
              if (typeof value === 'number')
                  value = Long.fromNumber(value, false);
              else if (typeof value === 'string')
                  value = Long.fromString(value, false);
              else if (value.unsigned !== false) value = value.toSigned();
              var size = ByteBuffer.calculateVarint64(value),
                  part0 = value.toInt() >>> 0,
                  part1 = value.shiftRightUnsigned(28).toInt() >>> 0,
                  part2 = value.shiftRightUnsigned(56).toInt() >>> 0;
              offset += size;
              var capacity11 = this.buffer.length;
              if (offset > capacity11)
                  this.resize((capacity11 *= 2) > offset ? capacity11 : offset);
              offset -= size;
              switch (size) {
                  case 10: this.buffer[offset+9] = (part2 >>>  7) & 0x01;
                  case 9 : this.buffer[offset+8] = size !== 9 ? (part2       ) | 0x80 : (part2       ) & 0x7F;
                  case 8 : this.buffer[offset+7] = size !== 8 ? (part1 >>> 21) | 0x80 : (part1 >>> 21) & 0x7F;
                  case 7 : this.buffer[offset+6] = size !== 7 ? (part1 >>> 14) | 0x80 : (part1 >>> 14) & 0x7F;
                  case 6 : this.buffer[offset+5] = size !== 6 ? (part1 >>>  7) | 0x80 : (part1 >>>  7) & 0x7F;
                  case 5 : this.buffer[offset+4] = size !== 5 ? (part1       ) | 0x80 : (part1       ) & 0x7F;
                  case 4 : this.buffer[offset+3] = size !== 4 ? (part0 >>> 21) | 0x80 : (part0 >>> 21) & 0x7F;
                  case 3 : this.buffer[offset+2] = size !== 3 ? (part0 >>> 14) | 0x80 : (part0 >>> 14) & 0x7F;
                  case 2 : this.buffer[offset+1] = size !== 2 ? (part0 >>>  7) | 0x80 : (part0 >>>  7) & 0x7F;
                  case 1 : this.buffer[offset  ] = size !== 1 ? (part0       ) | 0x80 : (part0       ) & 0x7F;
              }
              if (relative) {
                  this.offset += size;
                  return this;
              } else {
                  return size;
              }
          };
  
          /**
           * Writes a zig-zag encoded 64bit base 128 variable-length integer.
           * @param {number|Long} value Value to write
           * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
           *  written if omitted.
           * @returns {!ByteBuffer|number} `this` if offset is omitted, else the actual number of bytes written.
           * @expose
           */
          ByteBufferPrototype.writeVarint64ZigZag = function(value, offset) {
              return this.writeVarint64(ByteBuffer.zigZagEncode64(value), offset);
          };
  
          /**
           * Reads a 64bit base 128 variable-length integer. Requires Long.js.
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
           *  read if omitted.
           * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
           *  the actual number of bytes read.
           * @throws {Error} If it's not a valid varint
           * @expose
           */
          ByteBufferPrototype.readVarint64 = function(offset) {
              var relative = typeof offset === 'undefined';
              if (relative) offset = this.offset;
              if (!this.noAssert) {
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + 1 > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
              }
              // ref: src/google/protobuf/io/coded_stream.cc
              var start = offset,
                  part0 = 0,
                  part1 = 0,
                  part2 = 0,
                  b  = 0;
              b = this.buffer[offset++]; part0  = (b & 0x7F)      ; if ( b & 0x80                                                   ) {
              b = this.buffer[offset++]; part0 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part0 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part0 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part1  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part1 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part1 |= (b & 0x7F) << 14; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part1 |= (b & 0x7F) << 21; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part2  = (b & 0x7F)      ; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              b = this.buffer[offset++]; part2 |= (b & 0x7F) <<  7; if ((b & 0x80) || (this.noAssert && typeof b === 'undefined')) {
              throw Error("Buffer overrun"); }}}}}}}}}}
              var value = Long.fromBits(part0 | (part1 << 28), (part1 >>> 4) | (part2) << 24, false);
              if (relative) {
                  this.offset = offset;
                  return value;
              } else {
                  return {
                      'value': value,
                      'length': offset-start
                  };
              }
          };
  
          /**
           * Reads a zig-zag encoded 64bit base 128 variable-length integer. Requires Long.js.
           * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
           *  read if omitted.
           * @returns {!Long|!{value: Long, length: number}} The value read if offset is omitted, else the value read and
           *  the actual number of bytes read.
           * @throws {Error} If it's not a valid varint
           * @expose
           */
          ByteBufferPrototype.readVarint64ZigZag = function(offset) {
              var val = this.readVarint64(offset);
              if (val && val['value'] instanceof Long)
                  val["value"] = ByteBuffer.zigZagDecode64(val["value"]);
              else
                  val = ByteBuffer.zigZagDecode64(val);
              return val;
          };
  
      } // Long
  
  
      // types/strings/cstring
  
      /**
       * Writes a NULL-terminated UTF8 encoded string. For this to work the specified string must not contain any NULL
       *  characters itself.
       * @param {string} str String to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  contained in `str` + 1 if omitted.
       * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written
       * @expose
       */
      ByteBufferPrototype.writeCString = function(str, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          var i,
              k = str.length;
          if (!this.noAssert) {
              if (typeof str !== 'string')
                  throw TypeError("Illegal str: Not a string");
              for (i=0; i<k; ++i) {
                  if (str.charCodeAt(i) === 0)
                      throw RangeError("Illegal str: Contains NULL-characters");
              }
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          // UTF8 strings do not contain zero bytes in between except for the zero character, so:
          k = Buffer.byteLength(str, "utf8");
          offset += k+1;
          var capacity12 = this.buffer.length;
          if (offset > capacity12)
              this.resize((capacity12 *= 2) > offset ? capacity12 : offset);
          offset -= k+1;
          offset += this.buffer.write(str, offset, k, "utf8");
          this.buffer[offset++] = 0;
          if (relative) {
              this.offset = offset;
              return this;
          }
          return k;
      };
  
      /**
       * Reads a NULL-terminated UTF8 encoded string. For this to work the string read must not contain any NULL characters
       *  itself.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
       *  read and the actual number of bytes read.
       * @expose
       */
      ByteBufferPrototype.readCString = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 1 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
          }
          var start = offset,
              temp;
          // UTF8 strings do not contain zero bytes in between except for the zero character itself, so:
          do {
              if (offset >= this.buffer.length)
                  throw RangeError("Index out of range: "+offset+" <= "+this.buffer.length);
              temp = this.buffer[offset++];
          } while (temp !== 0);
          var str = this.buffer.toString("utf8", start, offset-1);
          if (relative) {
              this.offset = offset;
              return str;
          } else {
              return {
                  "string": str,
                  "length": offset - start
              };
          }
      };
  
      // types/strings/istring
  
      /**
       * Writes a length as uint32 prefixed UTF8 encoded string.
       * @param {string} str String to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written
       * @expose
       * @see ByteBuffer#writeVarint32
       */
      ByteBufferPrototype.writeIString = function(str, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof str !== 'string')
                  throw TypeError("Illegal str: Not a string");
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          var start = offset,
              k;
          k = Buffer.byteLength(str, "utf8");
          offset += 4+k;
          var capacity13 = this.buffer.length;
          if (offset > capacity13)
              this.resize((capacity13 *= 2) > offset ? capacity13 : offset);
          offset -= 4+k;
          if (this.littleEndian) {
              this.buffer[offset+3] = (k >>> 24) & 0xFF;
              this.buffer[offset+2] = (k >>> 16) & 0xFF;
              this.buffer[offset+1] = (k >>>  8) & 0xFF;
              this.buffer[offset  ] =  k         & 0xFF;
          } else {
              this.buffer[offset  ] = (k >>> 24) & 0xFF;
              this.buffer[offset+1] = (k >>> 16) & 0xFF;
              this.buffer[offset+2] = (k >>>  8) & 0xFF;
              this.buffer[offset+3] =  k         & 0xFF;
          }
          offset += 4;
          offset += this.buffer.write(str, offset, k, "utf8");
          if (relative) {
              this.offset = offset;
              return this;
          }
          return offset - start;
      };
  
      /**
       * Reads a length as uint32 prefixed UTF8 encoded string.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
       *  read and the actual number of bytes read.
       * @expose
       * @see ByteBuffer#readVarint32
       */
      ByteBufferPrototype.readIString = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 4 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+4+") <= "+this.buffer.length);
          }
          var start = offset;
          var len = this.readUint32(offset);
          var str = this.readUTF8String(len, ByteBuffer.METRICS_BYTES, offset += 4);
          offset += str['length'];
          if (relative) {
              this.offset = offset;
              return str['string'];
          } else {
              return {
                  'string': str['string'],
                  'length': offset - start
              };
          }
      };
  
      // types/strings/utf8string
  
      /**
       * Metrics representing number of UTF8 characters. Evaluates to `c`.
       * @type {string}
       * @const
       * @expose
       */
      ByteBuffer.METRICS_CHARS = 'c';
  
      /**
       * Metrics representing number of bytes. Evaluates to `b`.
       * @type {string}
       * @const
       * @expose
       */
      ByteBuffer.METRICS_BYTES = 'b';
  
      /**
       * Writes an UTF8 encoded string.
       * @param {string} str String to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
       * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
       * @expose
       */
      ByteBufferPrototype.writeUTF8String = function(str, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          var k;
          k = Buffer.byteLength(str, "utf8");
          offset += k;
          var capacity14 = this.buffer.length;
          if (offset > capacity14)
              this.resize((capacity14 *= 2) > offset ? capacity14 : offset);
          offset -= k;
          offset += this.buffer.write(str, offset, k, "utf8");
          if (relative) {
              this.offset = offset;
              return this;
          }
          return k;
      };
  
      /**
       * Writes an UTF8 encoded string. This is an alias of {@link ByteBuffer#writeUTF8String}.
       * @function
       * @param {string} str String to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} if omitted.
       * @returns {!ByteBuffer|number} this if offset is omitted, else the actual number of bytes written.
       * @expose
       */
      ByteBufferPrototype.writeString = ByteBufferPrototype.writeUTF8String;
  
      /**
       * Calculates the number of UTF8 characters of a string. JavaScript itself uses UTF-16, so that a string's
       *  `length` property does not reflect its actual UTF8 size if it contains code points larger than 0xFFFF.
       * @param {string} str String to calculate
       * @returns {number} Number of UTF8 characters
       * @expose
       */
      ByteBuffer.calculateUTF8Chars = function(str) {
          return utfx.calculateUTF16asUTF8(stringSource(str))[0];
      };
  
      /**
       * Calculates the number of UTF8 bytes of a string.
       * @param {string} str String to calculate
       * @returns {number} Number of UTF8 bytes
       * @expose
       */
      ByteBuffer.calculateUTF8Bytes = function(str) {
          if (typeof str !== 'string')
              throw TypeError("Illegal argument: "+(typeof str));
          return Buffer.byteLength(str, "utf8");
      };
  
      /**
       * Calculates the number of UTF8 bytes of a string. This is an alias of {@link ByteBuffer.calculateUTF8Bytes}.
       * @function
       * @param {string} str String to calculate
       * @returns {number} Number of UTF8 bytes
       * @expose
       */
      ByteBuffer.calculateString = ByteBuffer.calculateUTF8Bytes;
  
      /**
       * Reads an UTF8 encoded string.
       * @param {number} length Number of characters or bytes to read.
       * @param {string=} metrics Metrics specifying what `length` is meant to count. Defaults to
       *  {@link ByteBuffer.METRICS_CHARS}.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
       *  read and the actual number of bytes read.
       * @expose
       */
      ByteBufferPrototype.readUTF8String = function(length, metrics, offset) {
          if (typeof metrics === 'number') {
              offset = metrics;
              metrics = undefined;
          }
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (typeof metrics === 'undefined') metrics = ByteBuffer.METRICS_CHARS;
          if (!this.noAssert) {
              if (typeof length !== 'number' || length % 1 !== 0)
                  throw TypeError("Illegal length: "+length+" (not an integer)");
              length |= 0;
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          var i = 0,
              start = offset,
              temp,
              sd;
          if (metrics === ByteBuffer.METRICS_CHARS) { // The same for node and the browser
              sd = stringDestination();
              utfx.decodeUTF8(function() {
                  return i < length && offset < this.limit ? this.buffer[offset++] : null;
              }.bind(this), function(cp) {
                  ++i; utfx.UTF8toUTF16(cp, sd);
              });
              if (i !== length)
                  throw RangeError("Illegal range: Truncated data, "+i+" == "+length);
              if (relative) {
                  this.offset = offset;
                  return sd();
              } else {
                  return {
                      "string": sd(),
                      "length": offset - start
                  };
              }
          } else if (metrics === ByteBuffer.METRICS_BYTES) {
              if (!this.noAssert) {
                  if (typeof offset !== 'number' || offset % 1 !== 0)
                      throw TypeError("Illegal offset: "+offset+" (not an integer)");
                  offset >>>= 0;
                  if (offset < 0 || offset + length > this.buffer.length)
                      throw RangeError("Illegal offset: 0 <= "+offset+" (+"+length+") <= "+this.buffer.length);
              }
              temp = this.buffer.toString("utf8", offset, offset+length);
              if (relative) {
                  this.offset += length;
                  return temp;
              } else {
                  return {
                      'string': temp,
                      'length': length
                  };
              }
          } else
              throw TypeError("Unsupported metrics: "+metrics);
      };
  
      /**
       * Reads an UTF8 encoded string. This is an alias of {@link ByteBuffer#readUTF8String}.
       * @function
       * @param {number} length Number of characters or bytes to read
       * @param {number=} metrics Metrics specifying what `n` is meant to count. Defaults to
       *  {@link ByteBuffer.METRICS_CHARS}.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
       *  read and the actual number of bytes read.
       * @expose
       */
      ByteBufferPrototype.readString = ByteBufferPrototype.readUTF8String;
  
      // types/strings/vstring
  
      /**
       * Writes a length as varint32 prefixed UTF8 encoded string.
       * @param {string} str String to write
       * @param {number=} offset Offset to write to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer|number} `this` if `offset` is omitted, else the actual number of bytes written
       * @expose
       * @see ByteBuffer#writeVarint32
       */
      ByteBufferPrototype.writeVString = function(str, offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof str !== 'string')
                  throw TypeError("Illegal str: Not a string");
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          var start = offset,
              k, l;
          k = Buffer.byteLength(str, "utf8");
          l = ByteBuffer.calculateVarint32(k);
          offset += l+k;
          var capacity15 = this.buffer.length;
          if (offset > capacity15)
              this.resize((capacity15 *= 2) > offset ? capacity15 : offset);
          offset -= l+k;
          offset += this.writeVarint32(k, offset);
          offset += this.buffer.write(str, offset, k, "utf8");
          if (relative) {
              this.offset = offset;
              return this;
          }
          return offset - start;
      };
  
      /**
       * Reads a length as varint32 prefixed UTF8 encoded string.
       * @param {number=} offset Offset to read from. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {string|!{string: string, length: number}} The string read if offset is omitted, else the string
       *  read and the actual number of bytes read.
       * @expose
       * @see ByteBuffer#readVarint32
       */
      ByteBufferPrototype.readVString = function(offset) {
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 1 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+1+") <= "+this.buffer.length);
          }
          var start = offset;
          var len = this.readVarint32(offset);
          var str = this.readUTF8String(len['value'], ByteBuffer.METRICS_BYTES, offset += len['length']);
          offset += str['length'];
          if (relative) {
              this.offset = offset;
              return str['string'];
          } else {
              return {
                  'string': str['string'],
                  'length': offset - start
              };
          }
      };
  
  
      /**
       * Appends some data to this ByteBuffer. This will overwrite any contents behind the specified offset up to the appended
       *  data's length.
       * @param {!ByteBuffer|!Buffer|!ArrayBuffer|!Uint8Array|string} source Data to append. If `source` is a ByteBuffer, its
       * offsets will be modified according to the performed read operation.
       * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
       * @param {number=} offset Offset to append at. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       * @example A relative `<01 02>03.append(<04 05>)` will result in `<01 02 04 05>, 04 05|`
       * @example An absolute `<01 02>03.append(04 05>, 1)` will result in `<01 04>05, 04 05|`
       */
      ByteBufferPrototype.append = function(source, encoding, offset) {
          if (typeof encoding === 'number' || typeof encoding !== 'string') {
              offset = encoding;
              encoding = undefined;
          }
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          if (!(source instanceof ByteBuffer))
              source = ByteBuffer.wrap(source, encoding);
          var length = source.limit - source.offset;
          if (length <= 0) return this; // Nothing to append
          offset += length;
          var capacity16 = this.buffer.length;
          if (offset > capacity16)
              this.resize((capacity16 *= 2) > offset ? capacity16 : offset);
          offset -= length;
          source.buffer.copy(this.buffer, offset, source.offset, source.limit);
          source.offset += length;
          if (relative) this.offset += length;
          return this;
      };
  
      /**
       * Appends this ByteBuffer's contents to another ByteBuffer. This will overwrite any contents at and after the
          specified offset up to the length of this ByteBuffer's data.
       * @param {!ByteBuffer} target Target ByteBuffer
       * @param {number=} offset Offset to append to. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  read if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       * @see ByteBuffer#append
       */
      ByteBufferPrototype.appendTo = function(target, offset) {
          target.append(this, offset);
          return this;
      };
  
      /**
       * Enables or disables assertions of argument types and offsets. Assertions are enabled by default but you can opt to
       *  disable them if your code already makes sure that everything is valid.
       * @param {boolean} assert `true` to enable assertions, otherwise `false`
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.assert = function(assert) {
          this.noAssert = !assert;
          return this;
      };
  
      /**
       * Gets the capacity of this ByteBuffer's backing buffer.
       * @returns {number} Capacity of the backing buffer
       * @expose
       */
      ByteBufferPrototype.capacity = function() {
          return this.buffer.length;
      };
      /**
       * Clears this ByteBuffer's offsets by setting {@link ByteBuffer#offset} to `0` and {@link ByteBuffer#limit} to the
       *  backing buffer's capacity. Discards {@link ByteBuffer#markedOffset}.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.clear = function() {
          this.offset = 0;
          this.limit = this.buffer.length;
          this.markedOffset = -1;
          return this;
      };
  
      /**
       * Creates a cloned instance of this ByteBuffer, preset with this ByteBuffer's values for {@link ByteBuffer#offset},
       *  {@link ByteBuffer#markedOffset} and {@link ByteBuffer#limit}.
       * @param {boolean=} copy Whether to copy the backing buffer or to return another view on the same, defaults to `false`
       * @returns {!ByteBuffer} Cloned instance
       * @expose
       */
      ByteBufferPrototype.clone = function(copy) {
          var bb = new ByteBuffer(0, this.littleEndian, this.noAssert);
          if (copy) {
              var buffer = new Buffer(this.buffer.length);
              this.buffer.copy(buffer);
              bb.buffer = buffer;
          } else {
              bb.buffer = this.buffer;
          }
          bb.offset = this.offset;
          bb.markedOffset = this.markedOffset;
          bb.limit = this.limit;
          return bb;
      };
  
      /**
       * Compacts this ByteBuffer to be backed by a {@link ByteBuffer#buffer} of its contents' length. Contents are the bytes
       *  between {@link ByteBuffer#offset} and {@link ByteBuffer#limit}. Will set `offset = 0` and `limit = capacity` and
       *  adapt {@link ByteBuffer#markedOffset} to the same relative position if set.
       * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}
       * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.compact = function(begin, end) {
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          if (begin === 0 && end === this.buffer.length)
              return this; // Already compacted
          var len = end - begin;
          if (len === 0) {
              this.buffer = EMPTY_BUFFER;
              if (this.markedOffset >= 0) this.markedOffset -= begin;
              this.offset = 0;
              this.limit = 0;
              return this;
          }
          var buffer = new Buffer(len);
          this.buffer.copy(buffer, 0, begin, end);
          this.buffer = buffer;
          if (this.markedOffset >= 0) this.markedOffset -= begin;
          this.offset = 0;
          this.limit = len;
          return this;
      };
  
      /**
       * Creates a copy of this ByteBuffer's contents. Contents are the bytes between {@link ByteBuffer#offset} and
       *  {@link ByteBuffer#limit}.
       * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.
       * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
       * @returns {!ByteBuffer} Copy
       * @expose
       */
      ByteBufferPrototype.copy = function(begin, end) {
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          if (begin === end)
              return new ByteBuffer(0, this.littleEndian, this.noAssert);
          var capacity = end - begin,
              bb = new ByteBuffer(capacity, this.littleEndian, this.noAssert);
          bb.offset = 0;
          bb.limit = capacity;
          if (bb.markedOffset >= 0) bb.markedOffset -= begin;
          this.copyTo(bb, 0, begin, end);
          return bb;
      };
  
      /**
       * Copies this ByteBuffer's contents to another ByteBuffer. Contents are the bytes between {@link ByteBuffer#offset} and
       *  {@link ByteBuffer#limit}.
       * @param {!ByteBuffer} target Target ByteBuffer
       * @param {number=} targetOffset Offset to copy to. Will use and increase the target's {@link ByteBuffer#offset}
       *  by the number of bytes copied if omitted.
       * @param {number=} sourceOffset Offset to start copying from. Will use and increase {@link ByteBuffer#offset} by the
       *  number of bytes copied if omitted.
       * @param {number=} sourceLimit Offset to end copying from, defaults to {@link ByteBuffer#limit}
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.copyTo = function(target, targetOffset, sourceOffset, sourceLimit) {
          var relative,
              targetRelative;
          if (!this.noAssert) {
              if (!ByteBuffer.isByteBuffer(target))
                  throw TypeError("Illegal target: Not a ByteBuffer");
          }
          targetOffset = (targetRelative = typeof targetOffset === 'undefined') ? target.offset : targetOffset | 0;
          sourceOffset = (relative = typeof sourceOffset === 'undefined') ? this.offset : sourceOffset | 0;
          sourceLimit = typeof sourceLimit === 'undefined' ? this.limit : sourceLimit | 0;
  
          if (targetOffset < 0 || targetOffset > target.buffer.length)
              throw RangeError("Illegal target range: 0 <= "+targetOffset+" <= "+target.buffer.length);
          if (sourceOffset < 0 || sourceLimit > this.buffer.length)
              throw RangeError("Illegal source range: 0 <= "+sourceOffset+" <= "+this.buffer.length);
  
          var len = sourceLimit - sourceOffset;
          if (len === 0)
              return target; // Nothing to copy
  
          target.ensureCapacity(targetOffset + len);
  
          this.buffer.copy(target.buffer, targetOffset, sourceOffset, sourceLimit);
  
          if (relative) this.offset += len;
          if (targetRelative) target.offset += len;
  
          return this;
      };
  
      /**
       * Makes sure that this ByteBuffer is backed by a {@link ByteBuffer#buffer} of at least the specified capacity. If the
       *  current capacity is exceeded, it will be doubled. If double the current capacity is less than the required capacity,
       *  the required capacity will be used instead.
       * @param {number} capacity Required capacity
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.ensureCapacity = function(capacity) {
          var current = this.buffer.length;
          if (current < capacity)
              return this.resize((current *= 2) > capacity ? current : capacity);
          return this;
      };
  
      /**
       * Overwrites this ByteBuffer's contents with the specified value. Contents are the bytes between
       *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
       * @param {number|string} value Byte value to fill with. If given as a string, the first character is used.
       * @param {number=} begin Begin offset. Will use and increase {@link ByteBuffer#offset} by the number of bytes
       *  written if omitted. defaults to {@link ByteBuffer#offset}.
       * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
       * @returns {!ByteBuffer} this
       * @expose
       * @example `someByteBuffer.clear().fill(0)` fills the entire backing buffer with zeroes
       */
      ByteBufferPrototype.fill = function(value, begin, end) {
          var relative = typeof begin === 'undefined';
          if (relative) begin = this.offset;
          if (typeof value === 'string' && value.length > 0)
              value = value.charCodeAt(0);
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof value !== 'number' || value % 1 !== 0)
                  throw TypeError("Illegal value: "+value+" (not an integer)");
              value |= 0;
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          if (begin >= end)
              return this; // Nothing to fill
          this.buffer.fill(value, begin, end);
          begin = end;
          if (relative) this.offset = begin;
          return this;
      };
  
      /**
       * Makes this ByteBuffer ready for a new sequence of write or relative read operations. Sets `limit = offset` and
       *  `offset = 0`. Make sure always to flip a ByteBuffer when all relative read or write operations are complete.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.flip = function() {
          this.limit = this.offset;
          this.offset = 0;
          return this;
      };
      /**
       * Marks an offset on this ByteBuffer to be used later.
       * @param {number=} offset Offset to mark. Defaults to {@link ByteBuffer#offset}.
       * @returns {!ByteBuffer} this
       * @throws {TypeError} If `offset` is not a valid number
       * @throws {RangeError} If `offset` is out of bounds
       * @see ByteBuffer#reset
       * @expose
       */
      ByteBufferPrototype.mark = function(offset) {
          offset = typeof offset === 'undefined' ? this.offset : offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          this.markedOffset = offset;
          return this;
      };
      /**
       * Sets the byte order.
       * @param {boolean} littleEndian `true` for little endian byte order, `false` for big endian
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.order = function(littleEndian) {
          if (!this.noAssert) {
              if (typeof littleEndian !== 'boolean')
                  throw TypeError("Illegal littleEndian: Not a boolean");
          }
          this.littleEndian = !!littleEndian;
          return this;
      };
  
      /**
       * Switches (to) little endian byte order.
       * @param {boolean=} littleEndian Defaults to `true`, otherwise uses big endian
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.LE = function(littleEndian) {
          this.littleEndian = typeof littleEndian !== 'undefined' ? !!littleEndian : true;
          return this;
      };
  
      /**
       * Switches (to) big endian byte order.
       * @param {boolean=} bigEndian Defaults to `true`, otherwise uses little endian
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.BE = function(bigEndian) {
          this.littleEndian = typeof bigEndian !== 'undefined' ? !bigEndian : false;
          return this;
      };
      /**
       * Prepends some data to this ByteBuffer. This will overwrite any contents before the specified offset up to the
       *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer
       *  will be resized and its contents moved accordingly.
       * @param {!ByteBuffer|string||!Buffer} source Data to prepend. If `source` is a ByteBuffer, its offset will be modified
       *  according to the performed read operation.
       * @param {(string|number)=} encoding Encoding if `data` is a string ("base64", "hex", "binary", defaults to "utf8")
       * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes
       *  prepended if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       * @example A relative `00<01 02 03>.prepend(<04 05>)` results in `<04 05 01 02 03>, 04 05|`
       * @example An absolute `00<01 02 03>.prepend(<04 05>, 2)` results in `04<05 02 03>, 04 05|`
       */
      ByteBufferPrototype.prepend = function(source, encoding, offset) {
          if (typeof encoding === 'number' || typeof encoding !== 'string') {
              offset = encoding;
              encoding = undefined;
          }
          var relative = typeof offset === 'undefined';
          if (relative) offset = this.offset;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: "+offset+" (not an integer)");
              offset >>>= 0;
              if (offset < 0 || offset + 0 > this.buffer.length)
                  throw RangeError("Illegal offset: 0 <= "+offset+" (+"+0+") <= "+this.buffer.length);
          }
          if (!(source instanceof ByteBuffer))
              source = ByteBuffer.wrap(source, encoding);
          var len = source.limit - source.offset;
          if (len <= 0) return this; // Nothing to prepend
          var diff = len - offset;
          if (diff > 0) { // Not enough space before offset, so resize + move
              var buffer = new Buffer(this.buffer.length + diff);
              this.buffer.copy(buffer, len, offset, this.buffer.length);
              this.buffer = buffer;
              this.offset += diff;
              if (this.markedOffset >= 0) this.markedOffset += diff;
              this.limit += diff;
              offset += diff;
          }        source.buffer.copy(this.buffer, offset - len, source.offset, source.limit);
  
          source.offset = source.limit;
          if (relative)
              this.offset -= len;
          return this;
      };
  
      /**
       * Prepends this ByteBuffer to another ByteBuffer. This will overwrite any contents before the specified offset up to the
       *  prepended data's length. If there is not enough space available before the specified `offset`, the backing buffer
       *  will be resized and its contents moved accordingly.
       * @param {!ByteBuffer} target Target ByteBuffer
       * @param {number=} offset Offset to prepend at. Will use and decrease {@link ByteBuffer#offset} by the number of bytes
       *  prepended if omitted.
       * @returns {!ByteBuffer} this
       * @expose
       * @see ByteBuffer#prepend
       */
      ByteBufferPrototype.prependTo = function(target, offset) {
          target.prepend(this, offset);
          return this;
      };
      /**
       * Prints debug information about this ByteBuffer's contents.
       * @param {function(string)=} out Output function to call, defaults to console.log
       * @expose
       */
      ByteBufferPrototype.printDebug = function(out) {
          if (typeof out !== 'function') out = console.log.bind(console);
          out(
              this.toString()+"\n"+
              "-------------------------------------------------------------------\n"+
              this.toDebug(/* columns */ true)
          );
      };
  
      /**
       * Gets the number of remaining readable bytes. Contents are the bytes between {@link ByteBuffer#offset} and
       *  {@link ByteBuffer#limit}, so this returns `limit - offset`.
       * @returns {number} Remaining readable bytes. May be negative if `offset > limit`.
       * @expose
       */
      ByteBufferPrototype.remaining = function() {
          return this.limit - this.offset;
      };
      /**
       * Resets this ByteBuffer's {@link ByteBuffer#offset}. If an offset has been marked through {@link ByteBuffer#mark}
       *  before, `offset` will be set to {@link ByteBuffer#markedOffset}, which will then be discarded. If no offset has been
       *  marked, sets `offset = 0`.
       * @returns {!ByteBuffer} this
       * @see ByteBuffer#mark
       * @expose
       */
      ByteBufferPrototype.reset = function() {
          if (this.markedOffset >= 0) {
              this.offset = this.markedOffset;
              this.markedOffset = -1;
          } else {
              this.offset = 0;
          }
          return this;
      };
      /**
       * Resizes this ByteBuffer to be backed by a buffer of at least the given capacity. Will do nothing if already that
       *  large or larger.
       * @param {number} capacity Capacity required
       * @returns {!ByteBuffer} this
       * @throws {TypeError} If `capacity` is not a number
       * @throws {RangeError} If `capacity < 0`
       * @expose
       */
      ByteBufferPrototype.resize = function(capacity) {
          if (!this.noAssert) {
              if (typeof capacity !== 'number' || capacity % 1 !== 0)
                  throw TypeError("Illegal capacity: "+capacity+" (not an integer)");
              capacity |= 0;
              if (capacity < 0)
                  throw RangeError("Illegal capacity: 0 <= "+capacity);
          }
          if (this.buffer.length < capacity) {
              var buffer = new Buffer(capacity);
              this.buffer.copy(buffer);
              this.buffer = buffer;
          }
          return this;
      };
      /**
       * Reverses this ByteBuffer's contents.
       * @param {number=} begin Offset to start at, defaults to {@link ByteBuffer#offset}
       * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.reverse = function(begin, end) {
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          if (begin === end)
              return this; // Nothing to reverse
          Array.prototype.reverse.call(this.buffer.slice(begin, end));
          return this;
      };
      /**
       * Skips the next `length` bytes. This will just advance
       * @param {number} length Number of bytes to skip. May also be negative to move the offset back.
       * @returns {!ByteBuffer} this
       * @expose
       */
      ByteBufferPrototype.skip = function(length) {
          if (!this.noAssert) {
              if (typeof length !== 'number' || length % 1 !== 0)
                  throw TypeError("Illegal length: "+length+" (not an integer)");
              length |= 0;
          }
          var offset = this.offset + length;
          if (!this.noAssert) {
              if (offset < 0 || offset > this.buffer.length)
                  throw RangeError("Illegal length: 0 <= "+this.offset+" + "+length+" <= "+this.buffer.length);
          }
          this.offset = offset;
          return this;
      };
  
      /**
       * Slices this ByteBuffer by creating a cloned instance with `offset = begin` and `limit = end`.
       * @param {number=} begin Begin offset, defaults to {@link ByteBuffer#offset}.
       * @param {number=} end End offset, defaults to {@link ByteBuffer#limit}.
       * @returns {!ByteBuffer} Clone of this ByteBuffer with slicing applied, backed by the same {@link ByteBuffer#buffer}
       * @expose
       */
      ByteBufferPrototype.slice = function(begin, end) {
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          var bb = this.clone();
          bb.offset = begin;
          bb.limit = end;
          return bb;
      };
      /**
       * Returns a copy of the backing buffer that contains this ByteBuffer's contents. Contents are the bytes between
       *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
       * @param {boolean=} forceCopy If `true` returns a copy, otherwise returns a view referencing the same memory if
       *  possible. Defaults to `false`
       * @returns {!Buffer} Contents as a Buffer
       * @expose
       */
      ByteBufferPrototype.toBuffer = function(forceCopy) {
          var offset = this.offset,
              limit = this.limit;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: Not an integer");
              offset >>>= 0;
              if (typeof limit !== 'number' || limit % 1 !== 0)
                  throw TypeError("Illegal limit: Not an integer");
              limit >>>= 0;
              if (offset < 0 || offset > limit || limit > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+offset+" <= "+limit+" <= "+this.buffer.length);
          }
          if (forceCopy) {
              var buffer = new Buffer(limit - offset);
              this.buffer.copy(buffer, 0, offset, limit);
              return buffer;
          } else {
              if (offset === 0 && limit === this.buffer.length)
                  return this.buffer;
              else
                  return this.buffer.slice(offset, limit);
          }
      };
  
      /**
       * Returns a copy of the backing buffer compacted to contain this ByteBuffer's contents. Contents are the bytes between
       *  {@link ByteBuffer#offset} and {@link ByteBuffer#limit}.
       * @returns {!ArrayBuffer} Contents as an ArrayBuffer
       */
      ByteBufferPrototype.toArrayBuffer = function() {
          var offset = this.offset,
              limit = this.limit;
          if (!this.noAssert) {
              if (typeof offset !== 'number' || offset % 1 !== 0)
                  throw TypeError("Illegal offset: Not an integer");
              offset >>>= 0;
              if (typeof limit !== 'number' || limit % 1 !== 0)
                  throw TypeError("Illegal limit: Not an integer");
              limit >>>= 0;
              if (offset < 0 || offset > limit || limit > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+offset+" <= "+limit+" <= "+this.buffer.length);
          }
          var ab = new ArrayBuffer(limit - offset);
          if (memcpy) { // Fast
              memcpy(ab, 0, this.buffer, offset, limit);
          } else { // Slow
              var dst = new Uint8Array(ab);
              for (var i=offset; i<limit; ++i)
                  dst[i-offset] = this.buffer[i];
          }
          return ab;
      };
  
      /**
       * Converts the ByteBuffer's contents to a string.
       * @param {string=} encoding Output encoding. Returns an informative string representation if omitted but also allows
       *  direct conversion to "utf8", "hex", "base64" and "binary" encoding. "debug" returns a hex representation with
       *  highlighted offsets.
       * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}
       * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}
       * @returns {string} String representation
       * @throws {Error} If `encoding` is invalid
       * @expose
       */
      ByteBufferPrototype.toString = function(encoding, begin, end) {
          if (typeof encoding === 'undefined')
              return "ByteBufferNB(offset="+this.offset+",markedOffset="+this.markedOffset+",limit="+this.limit+",capacity="+this.capacity()+")";
          if (typeof encoding === 'number')
              encoding = "utf8",
              begin = encoding,
              end = begin;
          switch (encoding) {
              case "utf8":
                  return this.toUTF8(begin, end);
              case "base64":
                  return this.toBase64(begin, end);
              case "hex":
                  return this.toHex(begin, end);
              case "binary":
                  return this.toBinary(begin, end);
              case "debug":
                  return this.toDebug();
              case "columns":
                  return this.toColumns();
              default:
                  throw Error("Unsupported encoding: "+encoding);
          }
      };
  
      // encodings/base64
  
      /**
       * Encodes this ByteBuffer's contents to a base64 encoded string.
       * @param {number=} begin Offset to begin at, defaults to {@link ByteBuffer#offset}.
       * @param {number=} end Offset to end at, defaults to {@link ByteBuffer#limit}.
       * @returns {string} Base64 encoded string
       * @throws {RangeError} If `begin` or `end` is out of bounds
       * @expose
       */
      ByteBufferPrototype.toBase64 = function(begin, end) {
          if (typeof begin === 'undefined')
              begin = this.offset;
          if (typeof end === 'undefined')
              end = this.limit;
          begin = begin | 0; end = end | 0;
          if (begin < 0 || end > this.capacity || begin > end)
              throw RangeError("begin, end");
          return this.buffer.toString("base64", begin, end);
      };
  
      /**
       * Decodes a base64 encoded string to a ByteBuffer.
       * @param {string} str String to decode
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @returns {!ByteBuffer} ByteBuffer
       * @expose
       */
      ByteBuffer.fromBase64 = function(str, littleEndian) {
          return ByteBuffer.wrap(new Buffer(str, "base64"), littleEndian);
          return bb;
      };
  
      /**
       * Encodes a binary string to base64 like `window.btoa` does.
       * @param {string} str Binary string
       * @returns {string} Base64 encoded string
       * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.btoa
       * @expose
       */
      ByteBuffer.btoa = function(str) {
          return ByteBuffer.fromBinary(str).toBase64();
      };
  
      /**
       * Decodes a base64 encoded string to binary like `window.atob` does.
       * @param {string} b64 Base64 encoded string
       * @returns {string} Binary string
       * @see https://developer.mozilla.org/en-US/docs/Web/API/Window.atob
       * @expose
       */
      ByteBuffer.atob = function(b64) {
          return ByteBuffer.fromBase64(b64).toBinary();
      };
  
      // encodings/binary
  
      /**
       * Encodes this ByteBuffer to a binary encoded string, that is using only characters 0x00-0xFF as bytes.
       * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.
       * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.
       * @returns {string} Binary encoded string
       * @throws {RangeError} If `offset > limit`
       * @expose
       */
      ByteBufferPrototype.toBinary = function(begin, end) {
          if (typeof begin === 'undefined')
              begin = this.offset;
          if (typeof end === 'undefined')
              end = this.limit;
          begin |= 0; end |= 0;
          if (begin < 0 || end > this.capacity() || begin > end)
              throw RangeError("begin, end");
          return this.buffer.toString("binary", begin, end);
      };
  
      /**
       * Decodes a binary encoded string, that is using only characters 0x00-0xFF as bytes, to a ByteBuffer.
       * @param {string} str String to decode
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @returns {!ByteBuffer} ByteBuffer
       * @expose
       */
      ByteBuffer.fromBinary = function(str, littleEndian) {
          return ByteBuffer.wrap(new Buffer(str, "binary"), littleEndian);
          return bb;
      };
  
      // encodings/debug
  
      /**
       * Encodes this ByteBuffer to a hex encoded string with marked offsets. Offset symbols are:
       * * `<` : offset,
       * * `'` : markedOffset,
       * * `>` : limit,
       * * `|` : offset and limit,
       * * `[` : offset and markedOffset,
       * * `]` : markedOffset and limit,
       * * `!` : offset, markedOffset and limit
       * @param {boolean=} columns If `true` returns two columns hex + ascii, defaults to `false`
       * @returns {string|!Array.<string>} Debug string or array of lines if `asArray = true`
       * @expose
       * @example `>00'01 02<03` contains four bytes with `limit=0, markedOffset=1, offset=3`
       * @example `00[01 02 03>` contains four bytes with `offset=markedOffset=1, limit=4`
       * @example `00|01 02 03` contains four bytes with `offset=limit=1, markedOffset=-1`
       * @example `|` contains zero bytes with `offset=limit=0, markedOffset=-1`
       */
      ByteBufferPrototype.toDebug = function(columns) {
          var i = -1,
              k = this.buffer.length,
              b,
              hex = "",
              asc = "",
              out = "";
          while (i<k) {
              if (i !== -1) {
                  b = this.buffer[i];
                  if (b < 0x10) hex += "0"+b.toString(16).toUpperCase();
                  else hex += b.toString(16).toUpperCase();
                  if (columns)
                      asc += b > 32 && b < 127 ? String.fromCharCode(b) : '.';
              }
              ++i;
              if (columns) {
                  if (i > 0 && i % 16 === 0 && i !== k) {
                      while (hex.length < 3*16+3) hex += " ";
                      out += hex+asc+"\n";
                      hex = asc = "";
                  }
              }
              if (i === this.offset && i === this.limit)
                  hex += i === this.markedOffset ? "!" : "|";
              else if (i === this.offset)
                  hex += i === this.markedOffset ? "[" : "<";
              else if (i === this.limit)
                  hex += i === this.markedOffset ? "]" : ">";
              else
                  hex += i === this.markedOffset ? "'" : (columns || (i !== 0 && i !== k) ? " " : "");
          }
          if (columns && hex !== " ") {
              while (hex.length < 3*16+3)
                  hex += " ";
              out += hex + asc + "\n";
          }
          return columns ? out : hex;
      };
  
      /**
       * Decodes a hex encoded string with marked offsets to a ByteBuffer.
       * @param {string} str Debug string to decode (not be generated with `columns = true`)
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer} ByteBuffer
       * @expose
       * @see ByteBuffer#toDebug
       */
      ByteBuffer.fromDebug = function(str, littleEndian, noAssert) {
          var k = str.length,
              bb = new ByteBuffer(((k+1)/3)|0, littleEndian, noAssert);
          var i = 0, j = 0, ch, b,
              rs = false, // Require symbol next
              ho = false, hm = false, hl = false, // Already has offset (ho), markedOffset (hm), limit (hl)?
              fail = false;
          while (i<k) {
              switch (ch = str.charAt(i++)) {
                  case '!':
                      if (!noAssert) {
                          if (ho || hm || hl) {
                              fail = true;
                              break;
                          }
                          ho = hm = hl = true;
                      }
                      bb.offset = bb.markedOffset = bb.limit = j;
                      rs = false;
                      break;
                  case '|':
                      if (!noAssert) {
                          if (ho || hl) {
                              fail = true;
                              break;
                          }
                          ho = hl = true;
                      }
                      bb.offset = bb.limit = j;
                      rs = false;
                      break;
                  case '[':
                      if (!noAssert) {
                          if (ho || hm) {
                              fail = true;
                              break;
                          }
                          ho = hm = true;
                      }
                      bb.offset = bb.markedOffset = j;
                      rs = false;
                      break;
                  case '<':
                      if (!noAssert) {
                          if (ho) {
                              fail = true;
                              break;
                          }
                          ho = true;
                      }
                      bb.offset = j;
                      rs = false;
                      break;
                  case ']':
                      if (!noAssert) {
                          if (hl || hm) {
                              fail = true;
                              break;
                          }
                          hl = hm = true;
                      }
                      bb.limit = bb.markedOffset = j;
                      rs = false;
                      break;
                  case '>':
                      if (!noAssert) {
                          if (hl) {
                              fail = true;
                              break;
                          }
                          hl = true;
                      }
                      bb.limit = j;
                      rs = false;
                      break;
                  case "'":
                      if (!noAssert) {
                          if (hm) {
                              fail = true;
                              break;
                          }
                          hm = true;
                      }
                      bb.markedOffset = j;
                      rs = false;
                      break;
                  case ' ':
                      rs = false;
                      break;
                  default:
                      if (!noAssert) {
                          if (rs) {
                              fail = true;
                              break;
                          }
                      }
                      b = parseInt(ch+str.charAt(i++), 16);
                      if (!noAssert) {
                          if (isNaN(b) || b < 0 || b > 255)
                              throw TypeError("Illegal str: Not a debug encoded string");
                      }
                      bb.buffer[j++] = b;
                      rs = true;
              }
              if (fail)
                  throw TypeError("Illegal str: Invalid symbol at "+i);
          }
          if (!noAssert) {
              if (!ho || !hl)
                  throw TypeError("Illegal str: Missing offset or limit");
              if (j<bb.buffer.length)
                  throw TypeError("Illegal str: Not a debug encoded string (is it hex?) "+j+" < "+k);
          }
          return bb;
      };
  
      // encodings/hex
  
      /**
       * Encodes this ByteBuffer's contents to a hex encoded string.
       * @param {number=} begin Offset to begin at. Defaults to {@link ByteBuffer#offset}.
       * @param {number=} end Offset to end at. Defaults to {@link ByteBuffer#limit}.
       * @returns {string} Hex encoded string
       * @expose
       */
      ByteBufferPrototype.toHex = function(begin, end) {
          begin = typeof begin === 'undefined' ? this.offset : begin;
          end = typeof end === 'undefined' ? this.limit : end;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          return this.buffer.toString("hex", begin, end);
      };
  
      /**
       * Decodes a hex encoded string to a ByteBuffer.
       * @param {string} str String to decode
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer} ByteBuffer
       * @expose
       */
      ByteBuffer.fromHex = function(str, littleEndian, noAssert) {
          if (!noAssert) {
              if (typeof str !== 'string')
                  throw TypeError("Illegal str: Not a string");
              if (str.length % 2 !== 0)
                  throw TypeError("Illegal str: Length not a multiple of 2");
          }
          var bb = new ByteBuffer(0, littleEndian, true);
          bb.buffer = new Buffer(str, "hex");
          bb.limit = bb.buffer.length;
          return bb;
      };
  
      // utfx-embeddable
  
      /**
       * utfx-embeddable (c) 2014 Daniel Wirtz <dcode@dcode.io>
       * Released under the Apache License, Version 2.0
       * see: https://github.com/dcodeIO/utfx for details
       */
      var utfx = function() {
          "use strict";
  
          /**
           * utfx namespace.
           * @inner
           * @type {!Object.<string,*>}
           */
          var utfx = {};
  
          /**
           * Maximum valid code point.
           * @type {number}
           * @const
           */
          utfx.MAX_CODEPOINT = 0x10FFFF;
  
          /**
           * Encodes UTF8 code points to UTF8 bytes.
           * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
           *  respectively `null` if there are no more code points left or a single numeric code point.
           * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
           */
          utfx.encodeUTF8 = function(src, dst) {
              var cp = null;
              if (typeof src === 'number')
                  cp = src,
                  src = function() { return null; };
              while (cp !== null || (cp = src()) !== null) {
                  if (cp < 0x80)
                      dst(cp&0x7F);
                  else if (cp < 0x800)
                      dst(((cp>>6)&0x1F)|0xC0),
                      dst((cp&0x3F)|0x80);
                  else if (cp < 0x10000)
                      dst(((cp>>12)&0x0F)|0xE0),
                      dst(((cp>>6)&0x3F)|0x80),
                      dst((cp&0x3F)|0x80);
                  else
                      dst(((cp>>18)&0x07)|0xF0),
                      dst(((cp>>12)&0x3F)|0x80),
                      dst(((cp>>6)&0x3F)|0x80),
                      dst((cp&0x3F)|0x80);
                  cp = null;
              }
          };
  
          /**
           * Decodes UTF8 bytes to UTF8 code points.
           * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
           *  are no more bytes left.
           * @param {!function(number)} dst Code points destination as a function successively called with each decoded code point.
           * @throws {RangeError} If a starting byte is invalid in UTF8
           * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the
           *  remaining bytes.
           */
          utfx.decodeUTF8 = function(src, dst) {
              var a, b, c, d, fail = function(b) {
                  b = b.slice(0, b.indexOf(null));
                  var err = Error(b.toString());
                  err.name = "TruncatedError";
                  err['bytes'] = b;
                  throw err;
              };
              while ((a = src()) !== null) {
                  if ((a&0x80) === 0)
                      dst(a);
                  else if ((a&0xE0) === 0xC0)
                      ((b = src()) === null) && fail([a, b]),
                      dst(((a&0x1F)<<6) | (b&0x3F));
                  else if ((a&0xF0) === 0xE0)
                      ((b=src()) === null || (c=src()) === null) && fail([a, b, c]),
                      dst(((a&0x0F)<<12) | ((b&0x3F)<<6) | (c&0x3F));
                  else if ((a&0xF8) === 0xF0)
                      ((b=src()) === null || (c=src()) === null || (d=src()) === null) && fail([a, b, c ,d]),
                      dst(((a&0x07)<<18) | ((b&0x3F)<<12) | ((c&0x3F)<<6) | (d&0x3F));
                  else throw RangeError("Illegal starting byte: "+a);
              }
          };
  
          /**
           * Converts UTF16 characters to UTF8 code points.
           * @param {!function():number|null} src Characters source as a function returning the next char code respectively
           *  `null` if there are no more characters left.
           * @param {!function(number)} dst Code points destination as a function successively called with each converted code
           *  point.
           */
          utfx.UTF16toUTF8 = function(src, dst) {
              var c1, c2 = null;
              while (true) {
                  if ((c1 = c2 !== null ? c2 : src()) === null)
                      break;
                  if (c1 >= 0xD800 && c1 <= 0xDFFF) {
                      if ((c2 = src()) !== null) {
                          if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
                              dst((c1-0xD800)*0x400+c2-0xDC00+0x10000);
                              c2 = null; continue;
                          }
                      }
                  }
                  dst(c1);
              }
              if (c2 !== null) dst(c2);
          };
  
          /**
           * Converts UTF8 code points to UTF16 characters.
           * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
           *  respectively `null` if there are no more code points left or a single numeric code point.
           * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
           * @throws {RangeError} If a code point is out of range
           */
          utfx.UTF8toUTF16 = function(src, dst) {
              var cp = null;
              if (typeof src === 'number')
                  cp = src, src = function() { return null; };
              while (cp !== null || (cp = src()) !== null) {
                  if (cp <= 0xFFFF)
                      dst(cp);
                  else
                      cp -= 0x10000,
                      dst((cp>>10)+0xD800),
                      dst((cp%0x400)+0xDC00);
                  cp = null;
              }
          };
  
          /**
           * Converts and encodes UTF16 characters to UTF8 bytes.
           * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
           *  if there are no more characters left.
           * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
           */
          utfx.encodeUTF16toUTF8 = function(src, dst) {
              utfx.UTF16toUTF8(src, function(cp) {
                  utfx.encodeUTF8(cp, dst);
              });
          };
  
          /**
           * Decodes and converts UTF8 bytes to UTF16 characters.
           * @param {!function():number|null} src Bytes source as a function returning the next byte respectively `null` if there
           *  are no more bytes left.
           * @param {!function(number)} dst Characters destination as a function successively called with each converted char code.
           * @throws {RangeError} If a starting byte is invalid in UTF8
           * @throws {Error} If the last sequence is truncated. Has an array property `bytes` holding the remaining bytes.
           */
          utfx.decodeUTF8toUTF16 = function(src, dst) {
              utfx.decodeUTF8(src, function(cp) {
                  utfx.UTF8toUTF16(cp, dst);
              });
          };
  
          /**
           * Calculates the byte length of an UTF8 code point.
           * @param {number} cp UTF8 code point
           * @returns {number} Byte length
           */
          utfx.calculateCodePoint = function(cp) {
              return (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
          };
  
          /**
           * Calculates the number of UTF8 bytes required to store UTF8 code points.
           * @param {(!function():number|null)} src Code points source as a function returning the next code point respectively
           *  `null` if there are no more code points left.
           * @returns {number} The number of UTF8 bytes required
           */
          utfx.calculateUTF8 = function(src) {
              var cp, l=0;
              while ((cp = src()) !== null)
                  l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
              return l;
          };
  
          /**
           * Calculates the number of UTF8 code points respectively UTF8 bytes required to store UTF16 char codes.
           * @param {(!function():number|null)} src Characters source as a function returning the next char code respectively
           *  `null` if there are no more characters left.
           * @returns {!Array.<number>} The number of UTF8 code points at index 0 and the number of UTF8 bytes required at index 1.
           */
          utfx.calculateUTF16asUTF8 = function(src) {
              var n=0, l=0;
              utfx.UTF16toUTF8(src, function(cp) {
                  ++n; l += (cp < 0x80) ? 1 : (cp < 0x800) ? 2 : (cp < 0x10000) ? 3 : 4;
              });
              return [n,l];
          };
  
          return utfx;
      }();
  
      // encodings/utf8
  
      /**
       * Encodes this ByteBuffer's contents between {@link ByteBuffer#offset} and {@link ByteBuffer#limit} to an UTF8 encoded
       *  string.
       * @returns {string} Hex encoded string
       * @throws {RangeError} If `offset > limit`
       * @expose
       */
      ByteBufferPrototype.toUTF8 = function(begin, end) {
          if (typeof begin === 'undefined') begin = this.offset;
          if (typeof end === 'undefined') end = this.limit;
          if (!this.noAssert) {
              if (typeof begin !== 'number' || begin % 1 !== 0)
                  throw TypeError("Illegal begin: Not an integer");
              begin >>>= 0;
              if (typeof end !== 'number' || end % 1 !== 0)
                  throw TypeError("Illegal end: Not an integer");
              end >>>= 0;
              if (begin < 0 || begin > end || end > this.buffer.length)
                  throw RangeError("Illegal range: 0 <= "+begin+" <= "+end+" <= "+this.buffer.length);
          }
          return this.buffer.toString("utf8", begin, end);
      };
  
      /**
       * Decodes an UTF8 encoded string to a ByteBuffer.
       * @param {string} str String to decode
       * @param {boolean=} littleEndian Whether to use little or big endian byte order. Defaults to
       *  {@link ByteBuffer.DEFAULT_ENDIAN}.
       * @param {boolean=} noAssert Whether to skip assertions of offsets and values. Defaults to
       *  {@link ByteBuffer.DEFAULT_NOASSERT}.
       * @returns {!ByteBuffer} ByteBuffer
       * @expose
       */
      ByteBuffer.fromUTF8 = function(str, littleEndian, noAssert) {
          if (!noAssert)
              if (typeof str !== 'string')
                  throw TypeError("Illegal str: Not a string");
          var bb = new ByteBuffer(0, littleEndian, noAssert);
          bb.buffer = new Buffer(str, "utf8");
          bb.limit = bb.buffer.length;
          return bb;
      };
  
  
      /**
       * node-memcpy. This is an optional binding dependency and may not be present.
       * @function
       * @param {!(Buffer|ArrayBuffer|Uint8Array)} target Destination
       * @param {number|!(Buffer|ArrayBuffer)} targetStart Destination start, defaults to 0.
       * @param {(!(Buffer|ArrayBuffer|Uint8Array)|number)=} source Source
       * @param {number=} sourceStart Source start, defaults to 0.
       * @param {number=} sourceEnd Source end, defaults to capacity.
       * @returns {number} Number of bytes copied
       * @throws {Error} If any index is out of bounds
       * @expose
       */
      ByteBuffer.memcpy = memcpy;
  
      return ByteBuffer;
  
  })();
  
  
  /***/ }),
  
  /***/ 9107:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  "use strict";
  
  
  (function() {
    var PNGHEADER_BASE64,
      bufferpack,
      crc,
      ignoreChunkTypes,
      revertCgBIBuffer,
      streamToBuffer,
      streamifier,
      zlib,
      indexOf =
        [].indexOf ||
        function(item) {
          for (var i = 0, l = this.length; i < l; i++) {
            if (i in this && this[i] === item) return i;
          }
          return -1;
        };
  
    streamToBuffer = __nccwpck_require__(9956);
  
    bufferpack = __nccwpck_require__(5728);
  
    streamifier = __nccwpck_require__(2504);
  
    zlib = __nccwpck_require__(8761);
  
    crc = __nccwpck_require__(4738);
  
    PNGHEADER_BASE64 = "iVBORw0KGgo=";
  
    ignoreChunkTypes = ["CgBI", "iDOT"];
  
    module.exports = function(stream, callback) {
      return streamToBuffer(stream, function(err, buffer) {
        var output;
        if (err) {
          return callback(err);
        }
        try {
          output = revertCgBIBuffer(buffer);
          return callback(null, streamifier.createReadStream(output));
        } catch (e) {
          return callback(e);
        }
      });
    };
  
    module.exports.revert = revertCgBIBuffer = function(buffer) {
      let isIphoneCompressed = false;
      let offset = 0;
      let chunks = [];
      let idatCgbiData = new Buffer(0);
      let headerData = buffer.slice(0, 8);
      let ref,
        width,
        height,
        chunk,
        uncompressed,
        newData,
        j,
        y,
        ref1,
        ref2,
        k,
        x,
        idatData,
        chunkCRC,
        idat_chunk;
      offset += 8;
      if (headerData.toString("base64") !== PNGHEADER_BASE64) {
        throw new Error("not a png file");
      }
      while (offset < buffer.length) {
        chunk = {};
        let data = buffer.slice(offset, offset + 4);
        offset += 4;
        chunk.length = bufferpack.unpack("L>", data, 0)[0];
        data = buffer.slice(offset, offset + 4);
        offset += 4;
        chunk.type = data.toString();
        chunk.data = data = buffer.slice(offset, offset + chunk.length);
        offset += chunk.length;
        let dataCrc = buffer.slice(offset, offset + 4);
        offset += 4;
        chunk.crc = bufferpack.unpack("L>", dataCrc, 0)[0];
        if (chunk.type === "CgBI") {
          isIphoneCompressed = true;
        }
        if (((ref = chunk.type), indexOf.call(ignoreChunkTypes, ref) >= 0)) {
          continue;
        }
        if (chunk.type === "IHDR") {
          width = bufferpack.unpack("L>", data)[0];
          height = bufferpack.unpack("L>", data, 4)[0];
        }
        if (chunk.type === "IDAT" && isIphoneCompressed) {
          idatCgbiData = Buffer.concat([idatCgbiData, data]);
          continue;
        }
        if (chunk.type === "IEND" && isIphoneCompressed) {
          uncompressed = zlib.inflateRawSync(idatCgbiData);
          newData = new Buffer(uncompressed.length);
          let i = 0;
          for (
            y = j = 0, ref1 = height - 1;
            0 <= ref1 ? j <= ref1 : j >= ref1;
            y = 0 <= ref1 ? ++j : --j
          ) {
            newData[i] = uncompressed[i];
            i++;
            for (
              x = k = 0, ref2 = width - 1;
              0 <= ref2 ? k <= ref2 : k >= ref2;
              x = 0 <= ref2 ? ++k : --k
            ) {
              newData[i + 0] = uncompressed[i + 2];
              newData[i + 1] = uncompressed[i + 1];
              newData[i + 2] = uncompressed[i + 0];
              newData[i + 3] = uncompressed[i + 3];
              i += 4;
            }
          }
          idatData = zlib.deflateSync(newData);
          chunkCRC = crc.crc32("IDAT");
          chunkCRC = crc.crc32(idatData, chunkCRC);
          chunkCRC = (chunkCRC + 0x100000000) % 0x100000000;
          idat_chunk = {
            type: "IDAT",
            length: idatData.length,
            data: idatData,
            crc: chunkCRC
          };
          chunks.push(idat_chunk);
        }
        chunks.push(chunk);
      }
      let output = headerData;
      for (let l = 0, len = chunks.length; l < len; l++) {
        chunk = chunks[l];
        output = Buffer.concat([output, bufferpack.pack("L>", [chunk.length])]);
        output = Buffer.concat([output, new Buffer(chunk.type)]);
        if (chunk.length > 0) {
          output = Buffer.concat([output, new Buffer(chunk.data)]);
        }
        output = Buffer.concat([output, bufferpack.pack("L>", [chunk.crc])]);
      }
      return output;
    };
  }.call(this));
  
  
  /***/ }),
  
  /***/ 743:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(8604).default;
  
  
  /***/ }),
  
  /***/ 641:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(9989).default;
  
  
  /***/ }),
  
  /***/ 9351:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(5031).default;
  
  
  /***/ }),
  
  /***/ 228:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(1171).default;
  
  
  /***/ }),
  
  /***/ 1510:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(3713).default;
  
  
  /***/ }),
  
  /***/ 4484:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(9515).default;
  
  
  /***/ }),
  
  /***/ 168:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(8751).default;
  
  
  /***/ }),
  
  /***/ 170:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(7773).default;
  
  
  /***/ }),
  
  /***/ 8545:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(1429).default;
  
  
  /***/ }),
  
  /***/ 8367:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(4819).default;
  
  
  /***/ }),
  
  /***/ 6348:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = __nccwpck_require__(4767).default;
  
  
  /***/ }),
  
  /***/ 8604:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var crc1 = (0, _define_crc2.default)('crc1', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = ~~previous;
    var accum = 0;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      accum += byte;
    }
  
    crc += accum % 256;
    return crc % 256;
  });
  
  exports.default = crc1;
  
  
  /***/ }),
  
  /***/ 9989:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16 --generate=c`
  // prettier-ignore
  var TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc16 = (0, _define_crc2.default)('crc-16', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = ~~previous;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff;
    }
  
    return crc;
  });
  
  exports.default = crc16;
  
  
  /***/ }),
  
  /***/ 5031:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=ccitt --generate=c`
  // prettier-ignore
  var TABLE = [0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7, 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef, 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6, 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de, 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485, 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d, 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4, 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc, 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823, 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b, 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12, 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a, 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41, 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49, 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70, 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78, 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f, 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067, 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e, 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256, 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d, 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c, 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634, 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab, 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3, 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a, 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92, 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9, 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1, 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8, 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc16ccitt = (0, _define_crc2.default)('ccitt', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = (TABLE[(crc >> 8 ^ byte) & 0xff] ^ crc << 8) & 0xffff;
    }
  
    return crc;
  });
  
  exports.default = crc16ccitt;
  
  
  /***/ }),
  
  /***/ 1171:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=kermit --generate=c`
  // prettier-ignore
  var TABLE = [0x0000, 0x1189, 0x2312, 0x329b, 0x4624, 0x57ad, 0x6536, 0x74bf, 0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7, 0x1081, 0x0108, 0x3393, 0x221a, 0x56a5, 0x472c, 0x75b7, 0x643e, 0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876, 0x2102, 0x308b, 0x0210, 0x1399, 0x6726, 0x76af, 0x4434, 0x55bd, 0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5, 0x3183, 0x200a, 0x1291, 0x0318, 0x77a7, 0x662e, 0x54b5, 0x453c, 0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974, 0x4204, 0x538d, 0x6116, 0x709f, 0x0420, 0x15a9, 0x2732, 0x36bb, 0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0x8868, 0x99e1, 0xab7a, 0xbaf3, 0x5285, 0x430c, 0x7197, 0x601e, 0x14a1, 0x0528, 0x37b3, 0x263a, 0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72, 0x6306, 0x728f, 0x4014, 0x519d, 0x2522, 0x34ab, 0x0630, 0x17b9, 0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1, 0x7387, 0x620e, 0x5095, 0x411c, 0x35a3, 0x242a, 0x16b1, 0x0738, 0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70, 0x8408, 0x9581, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7, 0x0840, 0x19c9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff, 0x9489, 0x8500, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036, 0x18c1, 0x0948, 0x3bd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e, 0xa50a, 0xb483, 0x8618, 0x9791, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5, 0x2942, 0x38cb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd, 0xb58b, 0xa402, 0x9699, 0x8710, 0xf3af, 0xe226, 0xd0bd, 0xc134, 0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c, 0xc60c, 0xd785, 0xe51e, 0xf497, 0x8028, 0x91a1, 0xa33a, 0xb2b3, 0x4a44, 0x5bcd, 0x6956, 0x78df, 0x0c60, 0x1de9, 0x2f72, 0x3efb, 0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0x8120, 0xb3bb, 0xa232, 0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a, 0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0x8238, 0x93b1, 0x6b46, 0x7acf, 0x4854, 0x59dd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9, 0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330, 0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc16kermit = (0, _define_crc2.default)('kermit', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = typeof previous !== 'undefined' ? ~~previous : 0x0000;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff;
    }
  
    return crc;
  });
  
  exports.default = crc16kermit;
  
  
  /***/ }),
  
  /***/ 3713:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=crc-16-modbus --generate=c`
  // prettier-ignore
  var TABLE = [0x0000, 0xc0c1, 0xc181, 0x0140, 0xc301, 0x03c0, 0x0280, 0xc241, 0xc601, 0x06c0, 0x0780, 0xc741, 0x0500, 0xc5c1, 0xc481, 0x0440, 0xcc01, 0x0cc0, 0x0d80, 0xcd41, 0x0f00, 0xcfc1, 0xce81, 0x0e40, 0x0a00, 0xcac1, 0xcb81, 0x0b40, 0xc901, 0x09c0, 0x0880, 0xc841, 0xd801, 0x18c0, 0x1980, 0xd941, 0x1b00, 0xdbc1, 0xda81, 0x1a40, 0x1e00, 0xdec1, 0xdf81, 0x1f40, 0xdd01, 0x1dc0, 0x1c80, 0xdc41, 0x1400, 0xd4c1, 0xd581, 0x1540, 0xd701, 0x17c0, 0x1680, 0xd641, 0xd201, 0x12c0, 0x1380, 0xd341, 0x1100, 0xd1c1, 0xd081, 0x1040, 0xf001, 0x30c0, 0x3180, 0xf141, 0x3300, 0xf3c1, 0xf281, 0x3240, 0x3600, 0xf6c1, 0xf781, 0x3740, 0xf501, 0x35c0, 0x3480, 0xf441, 0x3c00, 0xfcc1, 0xfd81, 0x3d40, 0xff01, 0x3fc0, 0x3e80, 0xfe41, 0xfa01, 0x3ac0, 0x3b80, 0xfb41, 0x3900, 0xf9c1, 0xf881, 0x3840, 0x2800, 0xe8c1, 0xe981, 0x2940, 0xeb01, 0x2bc0, 0x2a80, 0xea41, 0xee01, 0x2ec0, 0x2f80, 0xef41, 0x2d00, 0xedc1, 0xec81, 0x2c40, 0xe401, 0x24c0, 0x2580, 0xe541, 0x2700, 0xe7c1, 0xe681, 0x2640, 0x2200, 0xe2c1, 0xe381, 0x2340, 0xe101, 0x21c0, 0x2080, 0xe041, 0xa001, 0x60c0, 0x6180, 0xa141, 0x6300, 0xa3c1, 0xa281, 0x6240, 0x6600, 0xa6c1, 0xa781, 0x6740, 0xa501, 0x65c0, 0x6480, 0xa441, 0x6c00, 0xacc1, 0xad81, 0x6d40, 0xaf01, 0x6fc0, 0x6e80, 0xae41, 0xaa01, 0x6ac0, 0x6b80, 0xab41, 0x6900, 0xa9c1, 0xa881, 0x6840, 0x7800, 0xb8c1, 0xb981, 0x7940, 0xbb01, 0x7bc0, 0x7a80, 0xba41, 0xbe01, 0x7ec0, 0x7f80, 0xbf41, 0x7d00, 0xbdc1, 0xbc81, 0x7c40, 0xb401, 0x74c0, 0x7580, 0xb541, 0x7700, 0xb7c1, 0xb681, 0x7640, 0x7200, 0xb2c1, 0xb381, 0x7340, 0xb101, 0x71c0, 0x7080, 0xb041, 0x5000, 0x90c1, 0x9181, 0x5140, 0x9301, 0x53c0, 0x5280, 0x9241, 0x9601, 0x56c0, 0x5780, 0x9741, 0x5500, 0x95c1, 0x9481, 0x5440, 0x9c01, 0x5cc0, 0x5d80, 0x9d41, 0x5f00, 0x9fc1, 0x9e81, 0x5e40, 0x5a00, 0x9ac1, 0x9b81, 0x5b40, 0x9901, 0x59c0, 0x5880, 0x9841, 0x8801, 0x48c0, 0x4980, 0x8941, 0x4b00, 0x8bc1, 0x8a81, 0x4a40, 0x4e00, 0x8ec1, 0x8f81, 0x4f40, 0x8d01, 0x4dc0, 0x4c80, 0x8c41, 0x4400, 0x84c1, 0x8581, 0x4540, 0x8701, 0x47c0, 0x4680, 0x8641, 0x8201, 0x42c0, 0x4380, 0x8341, 0x4100, 0x81c1, 0x8081, 0x4040];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc16modbus = (0, _define_crc2.default)('crc-16-modbus', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = typeof previous !== 'undefined' ? ~~previous : 0xffff;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = (TABLE[(crc ^ byte) & 0xff] ^ crc >> 8) & 0xffff;
    }
  
    return crc;
  });
  
  exports.default = crc16modbus;
  
  
  /***/ }),
  
  /***/ 9515:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  var crc16xmodem = (0, _define_crc2.default)('xmodem', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = typeof previous !== 'undefined' ? ~~previous : 0x0;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      var code = crc >>> 8 & 0xff;
  
      code ^= byte & 0xff;
      code ^= code >>> 4;
      crc = crc << 8 & 0xffff;
      crc ^= code;
      code = code << 5 & 0xffff;
      crc ^= code;
      code = code << 7 & 0xffff;
      crc ^= code;
    }
  
    return crc;
  });
  
  exports.default = crc16xmodem;
  
  
  /***/ }),
  
  /***/ 8751:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-drive --model=crc-24 --generate=c`
  // prettier-ignore
  var TABLE = [0x000000, 0x864cfb, 0x8ad50d, 0x0c99f6, 0x93e6e1, 0x15aa1a, 0x1933ec, 0x9f7f17, 0xa18139, 0x27cdc2, 0x2b5434, 0xad18cf, 0x3267d8, 0xb42b23, 0xb8b2d5, 0x3efe2e, 0xc54e89, 0x430272, 0x4f9b84, 0xc9d77f, 0x56a868, 0xd0e493, 0xdc7d65, 0x5a319e, 0x64cfb0, 0xe2834b, 0xee1abd, 0x685646, 0xf72951, 0x7165aa, 0x7dfc5c, 0xfbb0a7, 0x0cd1e9, 0x8a9d12, 0x8604e4, 0x00481f, 0x9f3708, 0x197bf3, 0x15e205, 0x93aefe, 0xad50d0, 0x2b1c2b, 0x2785dd, 0xa1c926, 0x3eb631, 0xb8faca, 0xb4633c, 0x322fc7, 0xc99f60, 0x4fd39b, 0x434a6d, 0xc50696, 0x5a7981, 0xdc357a, 0xd0ac8c, 0x56e077, 0x681e59, 0xee52a2, 0xe2cb54, 0x6487af, 0xfbf8b8, 0x7db443, 0x712db5, 0xf7614e, 0x19a3d2, 0x9fef29, 0x9376df, 0x153a24, 0x8a4533, 0x0c09c8, 0x00903e, 0x86dcc5, 0xb822eb, 0x3e6e10, 0x32f7e6, 0xb4bb1d, 0x2bc40a, 0xad88f1, 0xa11107, 0x275dfc, 0xdced5b, 0x5aa1a0, 0x563856, 0xd074ad, 0x4f0bba, 0xc94741, 0xc5deb7, 0x43924c, 0x7d6c62, 0xfb2099, 0xf7b96f, 0x71f594, 0xee8a83, 0x68c678, 0x645f8e, 0xe21375, 0x15723b, 0x933ec0, 0x9fa736, 0x19ebcd, 0x8694da, 0x00d821, 0x0c41d7, 0x8a0d2c, 0xb4f302, 0x32bff9, 0x3e260f, 0xb86af4, 0x2715e3, 0xa15918, 0xadc0ee, 0x2b8c15, 0xd03cb2, 0x567049, 0x5ae9bf, 0xdca544, 0x43da53, 0xc596a8, 0xc90f5e, 0x4f43a5, 0x71bd8b, 0xf7f170, 0xfb6886, 0x7d247d, 0xe25b6a, 0x641791, 0x688e67, 0xeec29c, 0x3347a4, 0xb50b5f, 0xb992a9, 0x3fde52, 0xa0a145, 0x26edbe, 0x2a7448, 0xac38b3, 0x92c69d, 0x148a66, 0x181390, 0x9e5f6b, 0x01207c, 0x876c87, 0x8bf571, 0x0db98a, 0xf6092d, 0x7045d6, 0x7cdc20, 0xfa90db, 0x65efcc, 0xe3a337, 0xef3ac1, 0x69763a, 0x578814, 0xd1c4ef, 0xdd5d19, 0x5b11e2, 0xc46ef5, 0x42220e, 0x4ebbf8, 0xc8f703, 0x3f964d, 0xb9dab6, 0xb54340, 0x330fbb, 0xac70ac, 0x2a3c57, 0x26a5a1, 0xa0e95a, 0x9e1774, 0x185b8f, 0x14c279, 0x928e82, 0x0df195, 0x8bbd6e, 0x872498, 0x016863, 0xfad8c4, 0x7c943f, 0x700dc9, 0xf64132, 0x693e25, 0xef72de, 0xe3eb28, 0x65a7d3, 0x5b59fd, 0xdd1506, 0xd18cf0, 0x57c00b, 0xc8bf1c, 0x4ef3e7, 0x426a11, 0xc426ea, 0x2ae476, 0xaca88d, 0xa0317b, 0x267d80, 0xb90297, 0x3f4e6c, 0x33d79a, 0xb59b61, 0x8b654f, 0x0d29b4, 0x01b042, 0x87fcb9, 0x1883ae, 0x9ecf55, 0x9256a3, 0x141a58, 0xefaaff, 0x69e604, 0x657ff2, 0xe33309, 0x7c4c1e, 0xfa00e5, 0xf69913, 0x70d5e8, 0x4e2bc6, 0xc8673d, 0xc4fecb, 0x42b230, 0xddcd27, 0x5b81dc, 0x57182a, 0xd154d1, 0x26359f, 0xa07964, 0xace092, 0x2aac69, 0xb5d37e, 0x339f85, 0x3f0673, 0xb94a88, 0x87b4a6, 0x01f85d, 0x0d61ab, 0x8b2d50, 0x145247, 0x921ebc, 0x9e874a, 0x18cbb1, 0xe37b16, 0x6537ed, 0x69ae1b, 0xefe2e0, 0x709df7, 0xf6d10c, 0xfa48fa, 0x7c0401, 0x42fa2f, 0xc4b6d4, 0xc82f22, 0x4e63d9, 0xd11cce, 0x575035, 0x5bc9c3, 0xdd8538];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc24 = (0, _define_crc2.default)('crc-24', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = typeof previous !== 'undefined' ? ~~previous : 0xb704ce;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = (TABLE[(crc >> 16 ^ byte) & 0xff] ^ crc << 8) & 0xffffff;
    }
  
    return crc;
  });
  
  exports.default = crc24;
  
  
  /***/ }),
  
  /***/ 7773:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=crc-32 --generate=c`
  // prettier-ignore
  var TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc32 = (0, _define_crc2.default)('crc-32', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = previous === 0 ? 0 : ~~previous ^ -1;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8;
    }
  
    return crc ^ -1;
  });
  
  exports.default = crc32;
  
  
  /***/ }),
  
  /***/ 1429:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=crc-8 --generate=c`
  // prettier-ignore
  var TABLE = [0x00, 0x07, 0x0e, 0x09, 0x1c, 0x1b, 0x12, 0x15, 0x38, 0x3f, 0x36, 0x31, 0x24, 0x23, 0x2a, 0x2d, 0x70, 0x77, 0x7e, 0x79, 0x6c, 0x6b, 0x62, 0x65, 0x48, 0x4f, 0x46, 0x41, 0x54, 0x53, 0x5a, 0x5d, 0xe0, 0xe7, 0xee, 0xe9, 0xfc, 0xfb, 0xf2, 0xf5, 0xd8, 0xdf, 0xd6, 0xd1, 0xc4, 0xc3, 0xca, 0xcd, 0x90, 0x97, 0x9e, 0x99, 0x8c, 0x8b, 0x82, 0x85, 0xa8, 0xaf, 0xa6, 0xa1, 0xb4, 0xb3, 0xba, 0xbd, 0xc7, 0xc0, 0xc9, 0xce, 0xdb, 0xdc, 0xd5, 0xd2, 0xff, 0xf8, 0xf1, 0xf6, 0xe3, 0xe4, 0xed, 0xea, 0xb7, 0xb0, 0xb9, 0xbe, 0xab, 0xac, 0xa5, 0xa2, 0x8f, 0x88, 0x81, 0x86, 0x93, 0x94, 0x9d, 0x9a, 0x27, 0x20, 0x29, 0x2e, 0x3b, 0x3c, 0x35, 0x32, 0x1f, 0x18, 0x11, 0x16, 0x03, 0x04, 0x0d, 0x0a, 0x57, 0x50, 0x59, 0x5e, 0x4b, 0x4c, 0x45, 0x42, 0x6f, 0x68, 0x61, 0x66, 0x73, 0x74, 0x7d, 0x7a, 0x89, 0x8e, 0x87, 0x80, 0x95, 0x92, 0x9b, 0x9c, 0xb1, 0xb6, 0xbf, 0xb8, 0xad, 0xaa, 0xa3, 0xa4, 0xf9, 0xfe, 0xf7, 0xf0, 0xe5, 0xe2, 0xeb, 0xec, 0xc1, 0xc6, 0xcf, 0xc8, 0xdd, 0xda, 0xd3, 0xd4, 0x69, 0x6e, 0x67, 0x60, 0x75, 0x72, 0x7b, 0x7c, 0x51, 0x56, 0x5f, 0x58, 0x4d, 0x4a, 0x43, 0x44, 0x19, 0x1e, 0x17, 0x10, 0x05, 0x02, 0x0b, 0x0c, 0x21, 0x26, 0x2f, 0x28, 0x3d, 0x3a, 0x33, 0x34, 0x4e, 0x49, 0x40, 0x47, 0x52, 0x55, 0x5c, 0x5b, 0x76, 0x71, 0x78, 0x7f, 0x6a, 0x6d, 0x64, 0x63, 0x3e, 0x39, 0x30, 0x37, 0x22, 0x25, 0x2c, 0x2b, 0x06, 0x01, 0x08, 0x0f, 0x1a, 0x1d, 0x14, 0x13, 0xae, 0xa9, 0xa0, 0xa7, 0xb2, 0xb5, 0xbc, 0xbb, 0x96, 0x91, 0x98, 0x9f, 0x8a, 0x8d, 0x84, 0x83, 0xde, 0xd9, 0xd0, 0xd7, 0xc2, 0xc5, 0xcc, 0xcb, 0xe6, 0xe1, 0xe8, 0xef, 0xfa, 0xfd, 0xf4, 0xf3];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc8 = (0, _define_crc2.default)('crc-8', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = ~~previous;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = TABLE[(crc ^ byte) & 0xff] & 0xff;
    }
  
    return crc;
  });
  
  exports.default = crc8;
  
  
  /***/ }),
  
  /***/ 4819:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=dallas-1-wire --generate=c`
  // prettier-ignore
  var TABLE = [0x00, 0x5e, 0xbc, 0xe2, 0x61, 0x3f, 0xdd, 0x83, 0xc2, 0x9c, 0x7e, 0x20, 0xa3, 0xfd, 0x1f, 0x41, 0x9d, 0xc3, 0x21, 0x7f, 0xfc, 0xa2, 0x40, 0x1e, 0x5f, 0x01, 0xe3, 0xbd, 0x3e, 0x60, 0x82, 0xdc, 0x23, 0x7d, 0x9f, 0xc1, 0x42, 0x1c, 0xfe, 0xa0, 0xe1, 0xbf, 0x5d, 0x03, 0x80, 0xde, 0x3c, 0x62, 0xbe, 0xe0, 0x02, 0x5c, 0xdf, 0x81, 0x63, 0x3d, 0x7c, 0x22, 0xc0, 0x9e, 0x1d, 0x43, 0xa1, 0xff, 0x46, 0x18, 0xfa, 0xa4, 0x27, 0x79, 0x9b, 0xc5, 0x84, 0xda, 0x38, 0x66, 0xe5, 0xbb, 0x59, 0x07, 0xdb, 0x85, 0x67, 0x39, 0xba, 0xe4, 0x06, 0x58, 0x19, 0x47, 0xa5, 0xfb, 0x78, 0x26, 0xc4, 0x9a, 0x65, 0x3b, 0xd9, 0x87, 0x04, 0x5a, 0xb8, 0xe6, 0xa7, 0xf9, 0x1b, 0x45, 0xc6, 0x98, 0x7a, 0x24, 0xf8, 0xa6, 0x44, 0x1a, 0x99, 0xc7, 0x25, 0x7b, 0x3a, 0x64, 0x86, 0xd8, 0x5b, 0x05, 0xe7, 0xb9, 0x8c, 0xd2, 0x30, 0x6e, 0xed, 0xb3, 0x51, 0x0f, 0x4e, 0x10, 0xf2, 0xac, 0x2f, 0x71, 0x93, 0xcd, 0x11, 0x4f, 0xad, 0xf3, 0x70, 0x2e, 0xcc, 0x92, 0xd3, 0x8d, 0x6f, 0x31, 0xb2, 0xec, 0x0e, 0x50, 0xaf, 0xf1, 0x13, 0x4d, 0xce, 0x90, 0x72, 0x2c, 0x6d, 0x33, 0xd1, 0x8f, 0x0c, 0x52, 0xb0, 0xee, 0x32, 0x6c, 0x8e, 0xd0, 0x53, 0x0d, 0xef, 0xb1, 0xf0, 0xae, 0x4c, 0x12, 0x91, 0xcf, 0x2d, 0x73, 0xca, 0x94, 0x76, 0x28, 0xab, 0xf5, 0x17, 0x49, 0x08, 0x56, 0xb4, 0xea, 0x69, 0x37, 0xd5, 0x8b, 0x57, 0x09, 0xeb, 0xb5, 0x36, 0x68, 0x8a, 0xd4, 0x95, 0xcb, 0x29, 0x77, 0xf4, 0xaa, 0x48, 0x16, 0xe9, 0xb7, 0x55, 0x0b, 0x88, 0xd6, 0x34, 0x6a, 0x2b, 0x75, 0x97, 0xc9, 0x4a, 0x14, 0xf6, 0xa8, 0x74, 0x2a, 0xc8, 0x96, 0x15, 0x4b, 0xa9, 0xf7, 0xb6, 0xe8, 0x0a, 0x54, 0xd7, 0x89, 0x6b, 0x35];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crc81wire = (0, _define_crc2.default)('dallas-1-wire', function (buf, previous) {
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = ~~previous;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = TABLE[(crc ^ byte) & 0xff] & 0xff;
    }
  
    return crc;
  });
  
  exports.default = crc81wire;
  
  
  /***/ }),
  
  /***/ 4767:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  var __webpack_unused_export__;
  
  
  __webpack_unused_export__ = ({
    value: true
  });
  
  var _buffer = __nccwpck_require__(4293);
  
  var _create_buffer = __nccwpck_require__(397);
  
  var _create_buffer2 = _interopRequireDefault(_create_buffer);
  
  var _define_crc = __nccwpck_require__(174);
  
  var _define_crc2 = _interopRequireDefault(_define_crc);
  
  function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  
  // Generated by `./pycrc.py --algorithm=table-driven --model=jam --generate=c`
  // prettier-ignore
  var TABLE = [0x00000000, 0x77073096, 0xee0e612c, 0x990951ba, 0x076dc419, 0x706af48f, 0xe963a535, 0x9e6495a3, 0x0edb8832, 0x79dcb8a4, 0xe0d5e91e, 0x97d2d988, 0x09b64c2b, 0x7eb17cbd, 0xe7b82d07, 0x90bf1d91, 0x1db71064, 0x6ab020f2, 0xf3b97148, 0x84be41de, 0x1adad47d, 0x6ddde4eb, 0xf4d4b551, 0x83d385c7, 0x136c9856, 0x646ba8c0, 0xfd62f97a, 0x8a65c9ec, 0x14015c4f, 0x63066cd9, 0xfa0f3d63, 0x8d080df5, 0x3b6e20c8, 0x4c69105e, 0xd56041e4, 0xa2677172, 0x3c03e4d1, 0x4b04d447, 0xd20d85fd, 0xa50ab56b, 0x35b5a8fa, 0x42b2986c, 0xdbbbc9d6, 0xacbcf940, 0x32d86ce3, 0x45df5c75, 0xdcd60dcf, 0xabd13d59, 0x26d930ac, 0x51de003a, 0xc8d75180, 0xbfd06116, 0x21b4f4b5, 0x56b3c423, 0xcfba9599, 0xb8bda50f, 0x2802b89e, 0x5f058808, 0xc60cd9b2, 0xb10be924, 0x2f6f7c87, 0x58684c11, 0xc1611dab, 0xb6662d3d, 0x76dc4190, 0x01db7106, 0x98d220bc, 0xefd5102a, 0x71b18589, 0x06b6b51f, 0x9fbfe4a5, 0xe8b8d433, 0x7807c9a2, 0x0f00f934, 0x9609a88e, 0xe10e9818, 0x7f6a0dbb, 0x086d3d2d, 0x91646c97, 0xe6635c01, 0x6b6b51f4, 0x1c6c6162, 0x856530d8, 0xf262004e, 0x6c0695ed, 0x1b01a57b, 0x8208f4c1, 0xf50fc457, 0x65b0d9c6, 0x12b7e950, 0x8bbeb8ea, 0xfcb9887c, 0x62dd1ddf, 0x15da2d49, 0x8cd37cf3, 0xfbd44c65, 0x4db26158, 0x3ab551ce, 0xa3bc0074, 0xd4bb30e2, 0x4adfa541, 0x3dd895d7, 0xa4d1c46d, 0xd3d6f4fb, 0x4369e96a, 0x346ed9fc, 0xad678846, 0xda60b8d0, 0x44042d73, 0x33031de5, 0xaa0a4c5f, 0xdd0d7cc9, 0x5005713c, 0x270241aa, 0xbe0b1010, 0xc90c2086, 0x5768b525, 0x206f85b3, 0xb966d409, 0xce61e49f, 0x5edef90e, 0x29d9c998, 0xb0d09822, 0xc7d7a8b4, 0x59b33d17, 0x2eb40d81, 0xb7bd5c3b, 0xc0ba6cad, 0xedb88320, 0x9abfb3b6, 0x03b6e20c, 0x74b1d29a, 0xead54739, 0x9dd277af, 0x04db2615, 0x73dc1683, 0xe3630b12, 0x94643b84, 0x0d6d6a3e, 0x7a6a5aa8, 0xe40ecf0b, 0x9309ff9d, 0x0a00ae27, 0x7d079eb1, 0xf00f9344, 0x8708a3d2, 0x1e01f268, 0x6906c2fe, 0xf762575d, 0x806567cb, 0x196c3671, 0x6e6b06e7, 0xfed41b76, 0x89d32be0, 0x10da7a5a, 0x67dd4acc, 0xf9b9df6f, 0x8ebeeff9, 0x17b7be43, 0x60b08ed5, 0xd6d6a3e8, 0xa1d1937e, 0x38d8c2c4, 0x4fdff252, 0xd1bb67f1, 0xa6bc5767, 0x3fb506dd, 0x48b2364b, 0xd80d2bda, 0xaf0a1b4c, 0x36034af6, 0x41047a60, 0xdf60efc3, 0xa867df55, 0x316e8eef, 0x4669be79, 0xcb61b38c, 0xbc66831a, 0x256fd2a0, 0x5268e236, 0xcc0c7795, 0xbb0b4703, 0x220216b9, 0x5505262f, 0xc5ba3bbe, 0xb2bd0b28, 0x2bb45a92, 0x5cb36a04, 0xc2d7ffa7, 0xb5d0cf31, 0x2cd99e8b, 0x5bdeae1d, 0x9b64c2b0, 0xec63f226, 0x756aa39c, 0x026d930a, 0x9c0906a9, 0xeb0e363f, 0x72076785, 0x05005713, 0x95bf4a82, 0xe2b87a14, 0x7bb12bae, 0x0cb61b38, 0x92d28e9b, 0xe5d5be0d, 0x7cdcefb7, 0x0bdbdf21, 0x86d3d2d4, 0xf1d4e242, 0x68ddb3f8, 0x1fda836e, 0x81be16cd, 0xf6b9265b, 0x6fb077e1, 0x18b74777, 0x88085ae6, 0xff0f6a70, 0x66063bca, 0x11010b5c, 0x8f659eff, 0xf862ae69, 0x616bffd3, 0x166ccf45, 0xa00ae278, 0xd70dd2ee, 0x4e048354, 0x3903b3c2, 0xa7672661, 0xd06016f7, 0x4969474d, 0x3e6e77db, 0xaed16a4a, 0xd9d65adc, 0x40df0b66, 0x37d83bf0, 0xa9bcae53, 0xdebb9ec5, 0x47b2cf7f, 0x30b5ffe9, 0xbdbdf21c, 0xcabac28a, 0x53b39330, 0x24b4a3a6, 0xbad03605, 0xcdd70693, 0x54de5729, 0x23d967bf, 0xb3667a2e, 0xc4614ab8, 0x5d681b02, 0x2a6f2b94, 0xb40bbe37, 0xc30c8ea1, 0x5a05df1b, 0x2d02ef8d];
  
  if (typeof Int32Array !== 'undefined') TABLE = new Int32Array(TABLE);
  
  var crcjam = (0, _define_crc2.default)('jam', function (buf) {
    var previous = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : -1;
  
    if (!_buffer.Buffer.isBuffer(buf)) buf = (0, _create_buffer2.default)(buf);
  
    var crc = previous === 0 ? 0 : ~~previous;
  
    for (var index = 0; index < buf.length; index++) {
      var byte = buf[index];
      crc = TABLE[(crc ^ byte) & 0xff] ^ crc >>> 8;
    }
  
    return crc;
  });
  
  exports.default = crcjam;
  
  
  /***/ }),
  
  /***/ 397:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({
    value: true
  }));
  
  var _buffer = __nccwpck_require__(4293);
  
  var createBuffer = _buffer.Buffer.from && _buffer.Buffer.alloc && _buffer.Buffer.allocUnsafe && _buffer.Buffer.allocUnsafeSlow ? _buffer.Buffer.from : // support for Node < 5.10
  function (val) {
    return new _buffer.Buffer(val);
  };
  
  exports.default = createBuffer;
  
  
  /***/ }),
  
  /***/ 174:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  Object.defineProperty(exports, "__esModule", ({
    value: true
  }));
  
  exports.default = function (model, calc) {
    var fn = function fn(buf, previous) {
      return calc(buf, previous) >>> 0;
    };
    fn.signed = calc;
    fn.unsigned = fn;
    fn.model = model;
  
    return fn;
  };
  
  
  /***/ }),
  
  /***/ 4738:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  module.exports = {
    crc1: __nccwpck_require__(743),
    crc8: __nccwpck_require__(8545),
    crc81wire: __nccwpck_require__(8367),
    crc16: __nccwpck_require__(641),
    crc16ccitt: __nccwpck_require__(9351),
    crc16modbus: __nccwpck_require__(1510),
    crc16xmodem: __nccwpck_require__(4484),
    crc16kermit: __nccwpck_require__(228),
    crc24: __nccwpck_require__(168),
    crc32: __nccwpck_require__(170),
    crcjam: __nccwpck_require__(6348)
  };
  
  
  /***/ }),
  
  /***/ 3108:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  //parse Empty Node as self closing node
  const buildOptions = __nccwpck_require__(8445).buildOptions;
  
  const defaultOptions = {
    attributeNamePrefix: '@_',
    attrNodeName: false,
    textNodeName: '#text',
    ignoreAttributes: true,
    cdataTagName: false,
    cdataPositionChar: '\\c',
    format: false,
    indentBy: '  ',
    supressEmptyNode: false,
    tagValueProcessor: function(a) {
      return a;
    },
    attrValueProcessor: function(a) {
      return a;
    },
  };
  
  const props = [
    'attributeNamePrefix',
    'attrNodeName',
    'textNodeName',
    'ignoreAttributes',
    'cdataTagName',
    'cdataPositionChar',
    'format',
    'indentBy',
    'supressEmptyNode',
    'tagValueProcessor',
    'attrValueProcessor',
  ];
  
  function Parser(options) {
    this.options = buildOptions(options, defaultOptions, props);
    if (this.options.ignoreAttributes || this.options.attrNodeName) {
      this.isAttribute = function(/*a*/) {
        return false;
      };
    } else {
      this.attrPrefixLen = this.options.attributeNamePrefix.length;
      this.isAttribute = isAttribute;
    }
    if (this.options.cdataTagName) {
      this.isCDATA = isCDATA;
    } else {
      this.isCDATA = function(/*a*/) {
        return false;
      };
    }
    this.replaceCDATAstr = replaceCDATAstr;
    this.replaceCDATAarr = replaceCDATAarr;
  
    if (this.options.format) {
      this.indentate = indentate;
      this.tagEndChar = '>\n';
      this.newLine = '\n';
    } else {
      this.indentate = function() {
        return '';
      };
      this.tagEndChar = '>';
      this.newLine = '';
    }
  
    if (this.options.supressEmptyNode) {
      this.buildTextNode = buildEmptyTextNode;
      this.buildObjNode = buildEmptyObjNode;
    } else {
      this.buildTextNode = buildTextValNode;
      this.buildObjNode = buildObjectNode;
    }
  
    this.buildTextValNode = buildTextValNode;
    this.buildObjectNode = buildObjectNode;
  }
  
  Parser.prototype.parse = function(jObj) {
    return this.j2x(jObj, 0).val;
  };
  
  Parser.prototype.j2x = function(jObj, level) {
    let attrStr = '';
    let val = '';
    const keys = Object.keys(jObj);
    const len = keys.length;
    for (let i = 0; i < len; i++) {
      const key = keys[i];
      if (typeof jObj[key] === 'undefined') {
        // supress undefined node
      } else if (jObj[key] === null) {
        val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
      } else if (jObj[key] instanceof Date) {
        val += this.buildTextNode(jObj[key], key, '', level);
      } else if (typeof jObj[key] !== 'object') {
        //premitive type
        const attr = this.isAttribute(key);
        if (attr) {
          attrStr += ' ' + attr + '="' + this.options.attrValueProcessor('' + jObj[key]) + '"';
        } else if (this.isCDATA(key)) {
          if (jObj[this.options.textNodeName]) {
            val += this.replaceCDATAstr(jObj[this.options.textNodeName], jObj[key]);
          } else {
            val += this.replaceCDATAstr('', jObj[key]);
          }
        } else {
          //tag value
          if (key === this.options.textNodeName) {
            if (jObj[this.options.cdataTagName]) {
              //value will added while processing cdata
            } else {
              val += this.options.tagValueProcessor('' + jObj[key]);
            }
          } else {
            val += this.buildTextNode(jObj[key], key, '', level);
          }
        }
      } else if (Array.isArray(jObj[key])) {
        //repeated nodes
        if (this.isCDATA(key)) {
          val += this.indentate(level);
          if (jObj[this.options.textNodeName]) {
            val += this.replaceCDATAarr(jObj[this.options.textNodeName], jObj[key]);
          } else {
            val += this.replaceCDATAarr('', jObj[key]);
          }
        } else {
          //nested nodes
          const arrLen = jObj[key].length;
          for (let j = 0; j < arrLen; j++) {
            const item = jObj[key][j];
            if (typeof item === 'undefined') {
              // supress undefined node
            } else if (item === null) {
              val += this.indentate(level) + '<' + key + '/' + this.tagEndChar;
            } else if (typeof item === 'object') {
              const result = this.j2x(item, level + 1);
              val += this.buildObjNode(result.val, key, result.attrStr, level);
            } else {
              val += this.buildTextNode(item, key, '', level);
            }
          }
        }
      } else {
        //nested node
        if (this.options.attrNodeName && key === this.options.attrNodeName) {
          const Ks = Object.keys(jObj[key]);
          const L = Ks.length;
          for (let j = 0; j < L; j++) {
            attrStr += ' ' + Ks[j] + '="' + this.options.attrValueProcessor('' + jObj[key][Ks[j]]) + '"';
          }
        } else {
          const result = this.j2x(jObj[key], level + 1);
          val += this.buildObjNode(result.val, key, result.attrStr, level);
        }
      }
    }
    return {attrStr: attrStr, val: val};
  };
  
  function replaceCDATAstr(str, cdata) {
    str = this.options.tagValueProcessor('' + str);
    if (this.options.cdataPositionChar === '' || str === '') {
      return str + '<![CDATA[' + cdata + ']]' + this.tagEndChar;
    } else {
      return str.replace(this.options.cdataPositionChar, '<![CDATA[' + cdata + ']]' + this.tagEndChar);
    }
  }
  
  function replaceCDATAarr(str, cdata) {
    str = this.options.tagValueProcessor('' + str);
    if (this.options.cdataPositionChar === '' || str === '') {
      return str + '<![CDATA[' + cdata.join(']]><![CDATA[') + ']]' + this.tagEndChar;
    } else {
      for (let v in cdata) {
        str = str.replace(this.options.cdataPositionChar, '<![CDATA[' + cdata[v] + ']]>');
      }
      return str + this.newLine;
    }
  }
  
  function buildObjectNode(val, key, attrStr, level) {
    if (attrStr && !val.includes('<')) {
      return (
        this.indentate(level) +
        '<' +
        key +
        attrStr +
        '>' +
        val +
        //+ this.newLine
        // + this.indentate(level)
        '</' +
        key +
        this.tagEndChar
      );
    } else {
      return (
        this.indentate(level) +
        '<' +
        key +
        attrStr +
        this.tagEndChar +
        val +
        //+ this.newLine
        this.indentate(level) +
        '</' +
        key +
        this.tagEndChar
      );
    }
  }
  
  function buildEmptyObjNode(val, key, attrStr, level) {
    if (val !== '') {
      return this.buildObjectNode(val, key, attrStr, level);
    } else {
      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
      //+ this.newLine
    }
  }
  
  function buildTextValNode(val, key, attrStr, level) {
    return (
      this.indentate(level) +
      '<' +
      key +
      attrStr +
      '>' +
      this.options.tagValueProcessor(val) +
      '</' +
      key +
      this.tagEndChar
    );
  }
  
  function buildEmptyTextNode(val, key, attrStr, level) {
    if (val !== '') {
      return this.buildTextValNode(val, key, attrStr, level);
    } else {
      return this.indentate(level) + '<' + key + attrStr + '/' + this.tagEndChar;
    }
  }
  
  function indentate(level) {
    return this.options.indentBy.repeat(level);
  }
  
  function isAttribute(name /*, options*/) {
    if (name.startsWith(this.options.attributeNamePrefix)) {
      return name.substr(this.attrPrefixLen);
    } else {
      return false;
    }
  }
  
  function isCDATA(name) {
    return name === this.options.cdataTagName;
  }
  
  //formatting
  //indentation
  //\n after each closing or self closing tag
  
  module.exports = Parser;
  
  
  /***/ }),
  
  /***/ 7898:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  const char = function(a) {
    return String.fromCharCode(a);
  };
  
  const chars = {
    nilChar: char(176),
    missingChar: char(201),
    nilPremitive: char(175),
    missingPremitive: char(200),
  
    emptyChar: char(178),
    emptyValue: char(177), //empty Premitive
  
    boundryChar: char(179),
  
    objStart: char(198),
    arrStart: char(204),
    arrayEnd: char(185),
  };
  
  const charsArr = [
    chars.nilChar,
    chars.nilPremitive,
    chars.missingChar,
    chars.missingPremitive,
    chars.boundryChar,
    chars.emptyChar,
    chars.emptyValue,
    chars.arrayEnd,
    chars.objStart,
    chars.arrStart,
  ];
  
  const _e = function(node, e_schema, options) {
    if (typeof e_schema === 'string') {
      //premitive
      if (node && node[0] && node[0].val !== undefined) {
        return getValue(node[0].val, e_schema);
      } else {
        return getValue(node, e_schema);
      }
    } else {
      const hasValidData = hasData(node);
      if (hasValidData === true) {
        let str = '';
        if (Array.isArray(e_schema)) {
          //attributes can't be repeated. hence check in children tags only
          str += chars.arrStart;
          const itemSchema = e_schema[0];
          //var itemSchemaType = itemSchema;
          const arr_len = node.length;
  
          if (typeof itemSchema === 'string') {
            for (let arr_i = 0; arr_i < arr_len; arr_i++) {
              const r = getValue(node[arr_i].val, itemSchema);
              str = processValue(str, r);
            }
          } else {
            for (let arr_i = 0; arr_i < arr_len; arr_i++) {
              const r = _e(node[arr_i], itemSchema, options);
              str = processValue(str, r);
            }
          }
          str += chars.arrayEnd; //indicates that next item is not array item
        } else {
          //object
          str += chars.objStart;
          const keys = Object.keys(e_schema);
          if (Array.isArray(node)) {
            node = node[0];
          }
          for (let i in keys) {
            const key = keys[i];
            //a property defined in schema can be present either in attrsMap or children tags
            //options.textNodeName will not present in both maps, take it's value from val
            //options.attrNodeName will be present in attrsMap
            let r;
            if (!options.ignoreAttributes && node.attrsMap && node.attrsMap[key]) {
              r = _e(node.attrsMap[key], e_schema[key], options);
            } else if (key === options.textNodeName) {
              r = _e(node.val, e_schema[key], options);
            } else {
              r = _e(node.child[key], e_schema[key], options);
            }
            str = processValue(str, r);
          }
        }
        return str;
      } else {
        return hasValidData;
      }
    }
  };
  
  const getValue = function(a /*, type*/) {
    switch (a) {
      case undefined:
        return chars.missingPremitive;
      case null:
        return chars.nilPremitive;
      case '':
        return chars.emptyValue;
      default:
        return a;
    }
  };
  
  const processValue = function(str, r) {
    if (!isAppChar(r[0]) && !isAppChar(str[str.length - 1])) {
      str += chars.boundryChar;
    }
    return str + r;
  };
  
  const isAppChar = function(ch) {
    return charsArr.indexOf(ch) !== -1;
  };
  
  function hasData(jObj) {
    if (jObj === undefined) {
      return chars.missingChar;
    } else if (jObj === null) {
      return chars.nilChar;
    } else if (
      jObj.child &&
      Object.keys(jObj.child).length === 0 &&
      (!jObj.attrsMap || Object.keys(jObj.attrsMap).length === 0)
    ) {
      return chars.emptyChar;
    } else {
      return true;
    }
  }
  
  const x2j = __nccwpck_require__(4498);
  const buildOptions = __nccwpck_require__(8445).buildOptions;
  
  const convert2nimn = function(node, e_schema, options) {
    options = buildOptions(options, x2j.defaultOptions, x2j.props);
    return _e(node, e_schema, options);
  };
  
  exports.convert2nimn = convert2nimn;
  
  
  /***/ }),
  
  /***/ 1663:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const util = __nccwpck_require__(8445);
  
  const convertToJson = function(node, options, parentTagName) {
    const jObj = {};
  
    // when no child node or attr is present
    if ((!node.child || util.isEmptyObject(node.child)) && (!node.attrsMap || util.isEmptyObject(node.attrsMap))) {
      return util.isExist(node.val) ? node.val : '';
    }
  
    // otherwise create a textnode if node has some text
    if (util.isExist(node.val) && !(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) {
      const asArray = util.isTagNameInArrayMode(node.tagname, options.arrayMode, parentTagName)
      jObj[options.textNodeName] = asArray ? [node.val] : node.val;
    }
  
    util.merge(jObj, node.attrsMap, options.arrayMode);
  
    const keys = Object.keys(node.child);
    for (let index = 0; index < keys.length; index++) {
      const tagName = keys[index];
      if (node.child[tagName] && node.child[tagName].length > 1) {
        jObj[tagName] = [];
        for (let tag in node.child[tagName]) {
          if (node.child[tagName].hasOwnProperty(tag)) {
            jObj[tagName].push(convertToJson(node.child[tagName][tag], options, tagName));
          }
        }
      } else {
        const result = convertToJson(node.child[tagName][0], options, tagName);
        const asArray = (options.arrayMode === true && typeof result === 'object') || util.isTagNameInArrayMode(tagName, options.arrayMode, parentTagName);
        jObj[tagName] = asArray ? [result] : result;
      }
    }
  
    //add value
    return jObj;
  };
  
  exports.convertToJson = convertToJson;
  
  
  /***/ }),
  
  /***/ 2993:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const util = __nccwpck_require__(8445);
  const buildOptions = __nccwpck_require__(8445).buildOptions;
  const x2j = __nccwpck_require__(4498);
  
  //TODO: do it later
  const convertToJsonString = function(node, options) {
    options = buildOptions(options, x2j.defaultOptions, x2j.props);
  
    options.indentBy = options.indentBy || '';
    return _cToJsonStr(node, options, 0);
  };
  
  const _cToJsonStr = function(node, options, level) {
    let jObj = '{';
  
    //traver through all the children
    const keys = Object.keys(node.child);
  
    for (let index = 0; index < keys.length; index++) {
      var tagname = keys[index];
      if (node.child[tagname] && node.child[tagname].length > 1) {
        jObj += '"' + tagname + '" : [ ';
        for (var tag in node.child[tagname]) {
          jObj += _cToJsonStr(node.child[tagname][tag], options) + ' , ';
        }
        jObj = jObj.substr(0, jObj.length - 1) + ' ] '; //remove extra comma in last
      } else {
        jObj += '"' + tagname + '" : ' + _cToJsonStr(node.child[tagname][0], options) + ' ,';
      }
    }
    util.merge(jObj, node.attrsMap);
    //add attrsMap as new children
    if (util.isEmptyObject(jObj)) {
      return util.isExist(node.val) ? node.val : '';
    } else {
      if (util.isExist(node.val)) {
        if (!(typeof node.val === 'string' && (node.val === '' || node.val === options.cdataPositionChar))) {
          jObj += '"' + options.textNodeName + '" : ' + stringval(node.val);
        }
      }
    }
    //add value
    if (jObj[jObj.length - 1] === ',') {
      jObj = jObj.substr(0, jObj.length - 2);
    }
    return jObj + '}';
  };
  
  function stringval(v) {
    if (v === true || v === false || !isNaN(v)) {
      return v;
    } else {
      return '"' + v + '"';
    }
  }
  
  function indentate(options, level) {
    return options.indentBy.repeat(level);
  }
  
  exports.convertToJsonString = convertToJsonString;
  
  
  /***/ }),
  
  /***/ 4798:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const nodeToJson = __nccwpck_require__(1663);
  const xmlToNodeobj = __nccwpck_require__(4498);
  const x2xmlnode = __nccwpck_require__(4498);
  const buildOptions = __nccwpck_require__(8445).buildOptions;
  const validator = __nccwpck_require__(9742);
  
  exports.parse = function(xmlData, options, validationOption) {
    if( validationOption){
      if(validationOption === true) validationOption = {}
      
      const result = validator.validate(xmlData, validationOption);
      if (result !== true) {
        throw Error( result.err.msg)
      }
    }
    options = buildOptions(options, x2xmlnode.defaultOptions, x2xmlnode.props);
    const traversableObj = xmlToNodeobj.getTraversalObj(xmlData, options)
    //print(traversableObj, "  ");
    return nodeToJson.convertToJson(traversableObj, options);
  };
  exports.convertTonimn = __nccwpck_require__(7898).convert2nimn;
  exports.getTraversalObj = xmlToNodeobj.getTraversalObj;
  exports.convertToJson = nodeToJson.convertToJson;
  exports.convertToJsonString = __nccwpck_require__(2993).convertToJsonString;
  exports.validate = validator.validate;
  exports.j2xParser = __nccwpck_require__(3108);
  exports.parseToNimn = function(xmlData, schema, options) {
    return exports.convertTonimn(exports.getTraversalObj(xmlData, options), schema, options);
  };
  
  
  function print(xmlNode, indentation){
    if(xmlNode){
      console.log(indentation + "{")
      console.log(indentation + "  \"tagName\": \"" + xmlNode.tagname + "\", ");
      if(xmlNode.parent){
        console.log(indentation + "  \"parent\": \"" + xmlNode.parent.tagname  + "\", ");
      }
      console.log(indentation + "  \"val\": \"" + xmlNode.val  + "\", ");
      console.log(indentation + "  \"attrs\": " + JSON.stringify(xmlNode.attrsMap,null,4)  + ", ");
  
      if(xmlNode.child){
        console.log(indentation + "\"child\": {")
        const indentation2 = indentation + indentation;
        Object.keys(xmlNode.child).forEach( function(key) {
          const node = xmlNode.child[key];
  
          if(Array.isArray(node)){
            console.log(indentation +  "\""+key+"\" :[")
            node.forEach( function(item,index) {
              //console.log(indentation + " \""+index+"\" : [")
              print(item, indentation2);
            })
            console.log(indentation + "],")  
          }else{
            console.log(indentation + " \""+key+"\" : {")
            print(node, indentation2);
            console.log(indentation + "},")  
          }
        });
        console.log(indentation + "},")
      }
      console.log(indentation + "},")
    }
  }
  
  
  /***/ }),
  
  /***/ 8445:
  /***/ ((__unused_webpack_module, exports) => {
  
  "use strict";
  
  
  const nameStartChar = ':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';
  const nameChar = nameStartChar + '\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040';
  const nameRegexp = '[' + nameStartChar + '][' + nameChar + ']*'
  const regexName = new RegExp('^' + nameRegexp + '$');
  
  const getAllMatches = function(string, regex) {
    const matches = [];
    let match = regex.exec(string);
    while (match) {
      const allmatches = [];
      const len = match.length;
      for (let index = 0; index < len; index++) {
        allmatches.push(match[index]);
      }
      matches.push(allmatches);
      match = regex.exec(string);
    }
    return matches;
  };
  
  const isName = function(string) {
    const match = regexName.exec(string);
    return !(match === null || typeof match === 'undefined');
  };
  
  exports.isExist = function(v) {
    return typeof v !== 'undefined';
  };
  
  exports.isEmptyObject = function(obj) {
    return Object.keys(obj).length === 0;
  };
  
  /**
   * Copy all the properties of a into b.
   * @param {*} target
   * @param {*} a
   */
  exports.merge = function(target, a, arrayMode) {
    if (a) {
      const keys = Object.keys(a); // will return an array of own properties
      const len = keys.length; //don't make it inline
      for (let i = 0; i < len; i++) {
        if (arrayMode === 'strict') {
          target[keys[i]] = [ a[keys[i]] ];
        } else {
          target[keys[i]] = a[keys[i]];
        }
      }
    }
  };
  /* exports.merge =function (b,a){
    return Object.assign(b,a);
  } */
  
  exports.getValue = function(v) {
    if (exports.isExist(v)) {
      return v;
    } else {
      return '';
    }
  };
  
  // const fakeCall = function(a) {return a;};
  // const fakeCallNoReturn = function() {};
  
  exports.buildOptions = function(options, defaultOptions, props) {
    var newOptions = {};
    if (!options) {
      return defaultOptions; //if there are not options
    }
  
    for (let i = 0; i < props.length; i++) {
      if (options[props[i]] !== undefined) {
        newOptions[props[i]] = options[props[i]];
      } else {
        newOptions[props[i]] = defaultOptions[props[i]];
      }
    }
    return newOptions;
  };
  
  /**
   * Check if a tag name should be treated as array
   *
   * @param tagName the node tagname
   * @param arrayMode the array mode option
   * @param parentTagName the parent tag name
   * @returns {boolean} true if node should be parsed as array
   */
  exports.isTagNameInArrayMode = function (tagName, arrayMode, parentTagName) {
    if (arrayMode === false) {
      return false;
    } else if (arrayMode instanceof RegExp) {
      return arrayMode.test(tagName);
    } else if (typeof arrayMode === 'function') {
      return !!arrayMode(tagName, parentTagName);
    }
  
    return arrayMode === "strict";
  }
  
  exports.isName = isName;
  exports.getAllMatches = getAllMatches;
  exports.nameRegexp = nameRegexp;
  
  
  /***/ }),
  
  /***/ 9742:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const util = __nccwpck_require__(8445);
  
  const defaultOptions = {
    allowBooleanAttributes: false, //A tag can have attributes without any value
  };
  
  const props = ['allowBooleanAttributes'];
  
  //const tagsPattern = new RegExp("<\\/?([\\w:\\-_\.]+)\\s*\/?>","g");
  exports.validate = function (xmlData, options) {
    options = util.buildOptions(options, defaultOptions, props);
  
    //xmlData = xmlData.replace(/(\r\n|\n|\r)/gm,"");//make it single line
    //xmlData = xmlData.replace(/(^\s*<\?xml.*?\?>)/g,"");//Remove XML starting tag
    //xmlData = xmlData.replace(/(<!DOCTYPE[\s\w\"\.\/\-\:]+(\[.*\])*\s*>)/g,"");//Remove DOCTYPE
    const tags = [];
    let tagFound = false;
  
    //indicates that the root tag has been closed (aka. depth 0 has been reached)
    let reachedRoot = false;
  
    if (xmlData[0] === '\ufeff') {
      // check for byte order mark (BOM)
      xmlData = xmlData.substr(1);
    }
  
    for (let i = 0; i < xmlData.length; i++) {
  
      if (xmlData[i] === '<' && xmlData[i+1] === '?') {
        i+=2;
        i = readPI(xmlData,i);
        if (i.err) return i;
      }else if (xmlData[i] === '<') {
        //starting of tag
        //read until you reach to '>' avoiding any '>' in attribute value
  
        i++;
        
        if (xmlData[i] === '!') {
          i = readCommentAndCDATA(xmlData, i);
          continue;
        } else {
          let closingTag = false;
          if (xmlData[i] === '/') {
            //closing tag
            closingTag = true;
            i++;
          }
          //read tagname
          let tagName = '';
          for (; i < xmlData.length &&
            xmlData[i] !== '>' &&
            xmlData[i] !== ' ' &&
            xmlData[i] !== '\t' &&
            xmlData[i] !== '\n' &&
            xmlData[i] !== '\r'; i++
          ) {
            tagName += xmlData[i];
          }
          tagName = tagName.trim();
          //console.log(tagName);
  
          if (tagName[tagName.length - 1] === '/') {
            //self closing tag without attributes
            tagName = tagName.substring(0, tagName.length - 1);
            //continue;
            i--;
          }
          if (!validateTagName(tagName)) {
            let msg;
            if (tagName.trim().length === 0) {
              msg = "There is an unnecessary space between tag name and backward slash '</ ..'.";
            } else {
              msg = "Tag '"+tagName+"' is an invalid name.";
            }
            return getErrorObject('InvalidTag', msg, getLineNumberForPosition(xmlData, i));
          }
  
          const result = readAttributeStr(xmlData, i);
          if (result === false) {
            return getErrorObject('InvalidAttr', "Attributes for '"+tagName+"' have open quote.", getLineNumberForPosition(xmlData, i));
          }
          let attrStr = result.value;
          i = result.index;
  
          if (attrStr[attrStr.length - 1] === '/') {
            //self closing tag
            attrStr = attrStr.substring(0, attrStr.length - 1);
            const isValid = validateAttributeString(attrStr, options);
            if (isValid === true) {
              tagFound = true;
              //continue; //text may presents after self closing tag
            } else {
              //the result from the nested function returns the position of the error within the attribute
              //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
              //this gives us the absolute index in the entire xml, which we can use to find the line at last
              return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
            }
          } else if (closingTag) {
            if (!result.tagClosed) {
              return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' doesn't have proper closing.", getLineNumberForPosition(xmlData, i));
            } else if (attrStr.trim().length > 0) {
              return getErrorObject('InvalidTag', "Closing tag '"+tagName+"' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, i));
            } else {
              const otg = tags.pop();
              if (tagName !== otg) {
                return getErrorObject('InvalidTag', "Closing tag '"+otg+"' is expected inplace of '"+tagName+"'.", getLineNumberForPosition(xmlData, i));
              }
  
              //when there are no more tags, we reached the root level.
              if (tags.length == 0) {
                reachedRoot = true;
              }
            }
          } else {
            const isValid = validateAttributeString(attrStr, options);
            if (isValid !== true) {
              //the result from the nested function returns the position of the error within the attribute
              //in order to get the 'true' error line, we need to calculate the position where the attribute begins (i - attrStr.length) and then add the position within the attribute
              //this gives us the absolute index in the entire xml, which we can use to find the line at last
              return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line));
            }
  
            //if the root level has been reached before ...
            if (reachedRoot === true) {
              return getErrorObject('InvalidXml', 'Multiple possible root nodes found.', getLineNumberForPosition(xmlData, i));
            } else {
              tags.push(tagName);
            }
            tagFound = true;
          }
  
          //skip tag text value
          //It may include comments and CDATA value
          for (i++; i < xmlData.length; i++) {
            if (xmlData[i] === '<') {
              if (xmlData[i + 1] === '!') {
                //comment or CADATA
                i++;
                i = readCommentAndCDATA(xmlData, i);
                continue;
              } else if (xmlData[i+1] === '?') {
                i = readPI(xmlData, ++i);
                if (i.err) return i;
              } else{
                break;
              }
            } else if (xmlData[i] === '&') {
              const afterAmp = validateAmpersand(xmlData, i);
              if (afterAmp == -1)
                return getErrorObject('InvalidChar', "char '&' is not expected.", getLineNumberForPosition(xmlData, i));
              i = afterAmp;
            }
          } //end of reading tag text value
          if (xmlData[i] === '<') {
            i--;
          }
        }
      } else {
        if (xmlData[i] === ' ' || xmlData[i] === '\t' || xmlData[i] === '\n' || xmlData[i] === '\r') {
          continue;
        }
        return getErrorObject('InvalidChar', "char '"+xmlData[i]+"' is not expected.", getLineNumberForPosition(xmlData, i));
      }
    }
  
    if (!tagFound) {
      return getErrorObject('InvalidXml', 'Start tag expected.', 1);
    } else if (tags.length > 0) {
      return getErrorObject('InvalidXml', "Invalid '"+JSON.stringify(tags, null, 4).replace(/\r?\n/g, '')+"' found.", 1);
    }
  
    return true;
  };
  
  /**
   * Read Processing insstructions and skip
   * @param {*} xmlData
   * @param {*} i
   */
  function readPI(xmlData, i) {
    var start = i;
    for (; i < xmlData.length; i++) {
      if (xmlData[i] == '?' || xmlData[i] == ' ') {
        //tagname
        var tagname = xmlData.substr(start, i - start);
        if (i > 5 && tagname === 'xml') {
          return getErrorObject('InvalidXml', 'XML declaration allowed only at the start of the document.', getLineNumberForPosition(xmlData, i));
        } else if (xmlData[i] == '?' && xmlData[i + 1] == '>') {
          //check if valid attribut string
          i++;
          break;
        } else {
          continue;
        }
      }
    }
    return i;
  }
  
  function readCommentAndCDATA(xmlData, i) {
    if (xmlData.length > i + 5 && xmlData[i + 1] === '-' && xmlData[i + 2] === '-') {
      //comment
      for (i += 3; i < xmlData.length; i++) {
        if (xmlData[i] === '-' && xmlData[i + 1] === '-' && xmlData[i + 2] === '>') {
          i += 2;
          break;
        }
      }
    } else if (
      xmlData.length > i + 8 &&
      xmlData[i + 1] === 'D' &&
      xmlData[i + 2] === 'O' &&
      xmlData[i + 3] === 'C' &&
      xmlData[i + 4] === 'T' &&
      xmlData[i + 5] === 'Y' &&
      xmlData[i + 6] === 'P' &&
      xmlData[i + 7] === 'E'
    ) {
      let angleBracketsCount = 1;
      for (i += 8; i < xmlData.length; i++) {
        if (xmlData[i] === '<') {
          angleBracketsCount++;
        } else if (xmlData[i] === '>') {
          angleBracketsCount--;
          if (angleBracketsCount === 0) {
            break;
          }
        }
      }
    } else if (
      xmlData.length > i + 9 &&
      xmlData[i + 1] === '[' &&
      xmlData[i + 2] === 'C' &&
      xmlData[i + 3] === 'D' &&
      xmlData[i + 4] === 'A' &&
      xmlData[i + 5] === 'T' &&
      xmlData[i + 6] === 'A' &&
      xmlData[i + 7] === '['
    ) {
      for (i += 8; i < xmlData.length; i++) {
        if (xmlData[i] === ']' && xmlData[i + 1] === ']' && xmlData[i + 2] === '>') {
          i += 2;
          break;
        }
      }
    }
  
    return i;
  }
  
  var doubleQuote = '"';
  var singleQuote = "'";
  
  /**
   * Keep reading xmlData until '<' is found outside the attribute value.
   * @param {string} xmlData
   * @param {number} i
   */
  function readAttributeStr(xmlData, i) {
    let attrStr = '';
    let startChar = '';
    let tagClosed = false;
    for (; i < xmlData.length; i++) {
      if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) {
        if (startChar === '') {
          startChar = xmlData[i];
        } else if (startChar !== xmlData[i]) {
          //if vaue is enclosed with double quote then single quotes are allowed inside the value and vice versa
          continue;
        } else {
          startChar = '';
        }
      } else if (xmlData[i] === '>') {
        if (startChar === '') {
          tagClosed = true;
          break;
        }
      }
      attrStr += xmlData[i];
    }
    if (startChar !== '') {
      return false;
    }
  
    return {
      value: attrStr,
      index: i,
      tagClosed: tagClosed
    };
  }
  
  /**
   * Select all the attributes whether valid or invalid.
   */
  const validAttrStrRegxp = new RegExp('(\\s*)([^\\s=]+)(\\s*=)?(\\s*([\'"])(([\\s\\S])*?)\\5)?', 'g');
  
  //attr, ="sd", a="amit's", a="sd"b="saf", ab  cd=""
  
  function validateAttributeString(attrStr, options) {
    //console.log("start:"+attrStr+":end");
  
    //if(attrStr.trim().length === 0) return true; //empty string
  
    const matches = util.getAllMatches(attrStr, validAttrStrRegxp);
    const attrNames = {};
  
    for (let i = 0; i < matches.length; i++) {
      if (matches[i][1].length === 0) {
        //nospace before attribute name: a="sd"b="saf"
        return getErrorObject('InvalidAttr', "Attribute '"+matches[i][2]+"' has no space in starting.", getPositionFromMatch(attrStr, matches[i][0]))
      } else if (matches[i][3] === undefined && !options.allowBooleanAttributes) {
        //independent attribute: ab
        return getErrorObject('InvalidAttr', "boolean attribute '"+matches[i][2]+"' is not allowed.", getPositionFromMatch(attrStr, matches[i][0]));
      }
      /* else if(matches[i][6] === undefined){//attribute without value: ab=
                      return { err: { code:"InvalidAttr",msg:"attribute " + matches[i][2] + " has no value assigned."}};
                  } */
      const attrName = matches[i][2];
      if (!validateAttrName(attrName)) {
        return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is an invalid name.", getPositionFromMatch(attrStr, matches[i][0]));
      }
      if (!attrNames.hasOwnProperty(attrName)) {
        //check for duplicate attribute.
        attrNames[attrName] = 1;
      } else {
        return getErrorObject('InvalidAttr', "Attribute '"+attrName+"' is repeated.", getPositionFromMatch(attrStr, matches[i][0]));
      }
    }
  
    return true;
  }
  
  function validateNumberAmpersand(xmlData, i) {
    let re = /\d/;
    if (xmlData[i] === 'x') {
      i++;
      re = /[\da-fA-F]/;
    }
    for (; i < xmlData.length; i++) {
      if (xmlData[i] === ';')
        return i;
      if (!xmlData[i].match(re))
        break;
    }
    return -1;
  }
  
  function validateAmpersand(xmlData, i) {
    // https://www.w3.org/TR/xml/#dt-charref
    i++;
    if (xmlData[i] === ';')
      return -1;
    if (xmlData[i] === '#') {
      i++;
      return validateNumberAmpersand(xmlData, i);
    }
    let count = 0;
    for (; i < xmlData.length; i++, count++) {
      if (xmlData[i].match(/\w/) && count < 20)
        continue;
      if (xmlData[i] === ';')
        break;
      return -1;
    }
    return i;
  }
  
  function getErrorObject(code, message, lineNumber) {
    return {
      err: {
        code: code,
        msg: message,
        line: lineNumber,
      },
    };
  }
  
  function validateAttrName(attrName) {
    return util.isName(attrName);
  }
  
  // const startsWithXML = /^xml/i;
  
  function validateTagName(tagname) {
    return util.isName(tagname) /* && !tagname.match(startsWithXML) */;
  }
  
  //this function returns the line number for the character at the given index
  function getLineNumberForPosition(xmlData, index) {
    var lines = xmlData.substring(0, index).split(/\r?\n/);
    return lines.length;
  }
  
  //this function returns the position of the last character of match within attrStr
  function getPositionFromMatch(attrStr, match) {
    return attrStr.indexOf(match) + match.length;
  }
  
  
  /***/ }),
  
  /***/ 5820:
  /***/ ((module) => {
  
  "use strict";
  
  
  module.exports = function(tagname, parent, val) {
    this.tagname = tagname;
    this.parent = parent;
    this.child = {}; //child tags
    this.attrsMap = {}; //attributes map
    this.val = val; //text only
    this.addChild = function(child) {
      if (Array.isArray(this.child[child.tagname])) {
        //already presents
        this.child[child.tagname].push(child);
      } else {
        this.child[child.tagname] = [child];
      }
    };
  };
  
  
  /***/ }),
  
  /***/ 4498:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  const util = __nccwpck_require__(8445);
  const buildOptions = __nccwpck_require__(8445).buildOptions;
  const xmlNode = __nccwpck_require__(5820);
  const regx =
    '<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)'
    .replace(/NAME/g, util.nameRegexp);
  
  //const tagsRegx = new RegExp("<(\\/?[\\w:\\-\._]+)([^>]*)>(\\s*"+cdataRegx+")*([^<]+)?","g");
  //const tagsRegx = new RegExp("<(\\/?)((\\w*:)?([\\w:\\-\._]+))([^>]*)>([^<]*)("+cdataRegx+"([^<]*))*([^<]+)?","g");
  
  //polyfill
  if (!Number.parseInt && window.parseInt) {
    Number.parseInt = window.parseInt;
  }
  if (!Number.parseFloat && window.parseFloat) {
    Number.parseFloat = window.parseFloat;
  }
  
  const defaultOptions = {
    attributeNamePrefix: '@_',
    attrNodeName: false,
    textNodeName: '#text',
    ignoreAttributes: true,
    ignoreNameSpace: false,
    allowBooleanAttributes: false, //a tag can have attributes without any value
    //ignoreRootElement : false,
    parseNodeValue: true,
    parseAttributeValue: false,
    arrayMode: false,
    trimValues: true, //Trim string values of tag and attributes
    cdataTagName: false,
    cdataPositionChar: '\\c',
    tagValueProcessor: function(a, tagName) {
      return a;
    },
    attrValueProcessor: function(a, attrName) {
      return a;
    },
    stopNodes: []
    //decodeStrict: false,
  };
  
  exports.defaultOptions = defaultOptions;
  
  const props = [
    'attributeNamePrefix',
    'attrNodeName',
    'textNodeName',
    'ignoreAttributes',
    'ignoreNameSpace',
    'allowBooleanAttributes',
    'parseNodeValue',
    'parseAttributeValue',
    'arrayMode',
    'trimValues',
    'cdataTagName',
    'cdataPositionChar',
    'tagValueProcessor',
    'attrValueProcessor',
    'parseTrueNumberOnly',
    'stopNodes'
  ];
  exports.props = props;
  
  /**
   * Trim -> valueProcessor -> parse value
   * @param {string} tagName
   * @param {string} val
   * @param {object} options
   */
  function processTagValue(tagName, val, options) {
    if (val) {
      if (options.trimValues) {
        val = val.trim();
      }
      val = options.tagValueProcessor(val, tagName);
      val = parseValue(val, options.parseNodeValue, options.parseTrueNumberOnly);
    }
  
    return val;
  }
  
  function resolveNameSpace(tagname, options) {
    if (options.ignoreNameSpace) {
      const tags = tagname.split(':');
      const prefix = tagname.charAt(0) === '/' ? '/' : '';
      if (tags[0] === 'xmlns') {
        return '';
      }
      if (tags.length === 2) {
        tagname = prefix + tags[1];
      }
    }
    return tagname;
  }
  
  function parseValue(val, shouldParse, parseTrueNumberOnly) {
    if (shouldParse && typeof val === 'string') {
      let parsed;
      if (val.trim() === '' || isNaN(val)) {
        parsed = val === 'true' ? true : val === 'false' ? false : val;
      } else {
        if (val.indexOf('0x') !== -1) {
          //support hexa decimal
          parsed = Number.parseInt(val, 16);
        } else if (val.indexOf('.') !== -1) {
          parsed = Number.parseFloat(val);
          val = val.replace(/\.?0+$/, "");
        } else {
          parsed = Number.parseInt(val, 10);
        }
        if (parseTrueNumberOnly) {
          parsed = String(parsed) === val ? parsed : val;
        }
      }
      return parsed;
    } else {
      if (util.isExist(val)) {
        return val;
      } else {
        return '';
      }
    }
  }
  
  //TODO: change regex to capture NS
  //const attrsRegx = new RegExp("([\\w\\-\\.\\:]+)\\s*=\\s*(['\"])((.|\n)*?)\\2","gm");
  const attrsRegx = new RegExp('([^\\s=]+)\\s*(=\\s*([\'"])(.*?)\\3)?', 'g');
  
  function buildAttributesMap(attrStr, options) {
    if (!options.ignoreAttributes && typeof attrStr === 'string') {
      attrStr = attrStr.replace(/\r?\n/g, ' ');
      //attrStr = attrStr || attrStr.trim();
  
      const matches = util.getAllMatches(attrStr, attrsRegx);
      const len = matches.length; //don't make it inline
      const attrs = {};
      for (let i = 0; i < len; i++) {
        const attrName = resolveNameSpace(matches[i][1], options);
        if (attrName.length) {
          if (matches[i][4] !== undefined) {
            if (options.trimValues) {
              matches[i][4] = matches[i][4].trim();
            }
            matches[i][4] = options.attrValueProcessor(matches[i][4], attrName);
            attrs[options.attributeNamePrefix + attrName] = parseValue(
              matches[i][4],
              options.parseAttributeValue,
              options.parseTrueNumberOnly
            );
          } else if (options.allowBooleanAttributes) {
            attrs[options.attributeNamePrefix + attrName] = true;
          }
        }
      }
      if (!Object.keys(attrs).length) {
        return;
      }
      if (options.attrNodeName) {
        const attrCollection = {};
        attrCollection[options.attrNodeName] = attrs;
        return attrCollection;
      }
      return attrs;
    }
  }
  
  const getTraversalObj = function(xmlData, options) {
    xmlData = xmlData.replace(/\r\n?/g, "\n");
    options = buildOptions(options, defaultOptions, props);
    const xmlObj = new xmlNode('!xml');
    let currentNode = xmlObj;
    let textData = "";
  
  //function match(xmlData){
    for(let i=0; i< xmlData.length; i++){
      const ch = xmlData[i];
      if(ch === '<'){
        if( xmlData[i+1] === '/') {//Closing Tag
          const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed.")
          let tagName = xmlData.substring(i+2,closeIndex).trim();
  
          if(options.ignoreNameSpace){
            const colonIndex = tagName.indexOf(":");
            if(colonIndex !== -1){
              tagName = tagName.substr(colonIndex+1);
            }
          }
  
          /* if (currentNode.parent) {
            currentNode.parent.val = util.getValue(currentNode.parent.val) + '' + processTagValue2(tagName, textData , options);
          } */
          if(currentNode){
            if(currentNode.val){
              currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(tagName, textData , options);
            }else{
              currentNode.val = processTagValue(tagName, textData , options);
            }
          }
  
          if (options.stopNodes.length && options.stopNodes.includes(currentNode.tagname)) {
            currentNode.child = []
            if (currentNode.attrsMap == undefined) { currentNode.attrsMap = {}}
            currentNode.val = xmlData.substr(currentNode.startIndex + 1, i - currentNode.startIndex - 1)
          }
          currentNode = currentNode.parent;
          textData = "";
          i = closeIndex;
        } else if( xmlData[i+1] === '?') {
          i = findClosingIndex(xmlData, "?>", i, "Pi Tag is not closed.")
        } else if(xmlData.substr(i + 1, 3) === '!--') {
          i = findClosingIndex(xmlData, "-->", i, "Comment is not closed.")
        } else if( xmlData.substr(i + 1, 2) === '!D') {
          const closeIndex = findClosingIndex(xmlData, ">", i, "DOCTYPE is not closed.")
          const tagExp = xmlData.substring(i, closeIndex);
          if(tagExp.indexOf("[") >= 0){
            i = xmlData.indexOf("]>", i) + 1;
          }else{
            i = closeIndex;
          }
        }else if(xmlData.substr(i + 1, 2) === '![') {
          const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2
          const tagExp = xmlData.substring(i + 9,closeIndex);
  
          //considerations
          //1. CDATA will always have parent node
          //2. A tag with CDATA is not a leaf node so it's value would be string type.
          if(textData){
            currentNode.val = util.getValue(currentNode.val) + '' + processTagValue(currentNode.tagname, textData , options);
            textData = "";
          }
  
          if (options.cdataTagName) {
            //add cdata node
            const childNode = new xmlNode(options.cdataTagName, currentNode, tagExp);
            currentNode.addChild(childNode);
            //for backtracking
            currentNode.val = util.getValue(currentNode.val) + options.cdataPositionChar;
            //add rest value to parent node
            if (tagExp) {
              childNode.val = tagExp;
            }
          } else {
            currentNode.val = (currentNode.val || '') + (tagExp || '');
          }
  
          i = closeIndex + 2;
        }else {//Opening tag
          const result = closingIndexForOpeningTag(xmlData, i+1)
          let tagExp = result.data;
          const closeIndex = result.index;
          const separatorIndex = tagExp.indexOf(" ");
          let tagName = tagExp;
          let shouldBuildAttributesMap = true;
          if(separatorIndex !== -1){
            tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, '');
            tagExp = tagExp.substr(separatorIndex + 1);
          }
  
          if(options.ignoreNameSpace){
            const colonIndex = tagName.indexOf(":");
            if(colonIndex !== -1){
              tagName = tagName.substr(colonIndex+1);
              shouldBuildAttributesMap = tagName !== result.data.substr(colonIndex + 1);
            }
          }
  
          //save text to parent node
          if (currentNode && textData) {
            if(currentNode.tagname !== '!xml'){
              currentNode.val = util.getValue(currentNode.val) + '' + processTagValue( currentNode.tagname, textData, options);
            }
          }
  
          if(tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1){//selfClosing tag
  
            if(tagName[tagName.length - 1] === "/"){ //remove trailing '/'
              tagName = tagName.substr(0, tagName.length - 1);
              tagExp = tagName;
            }else{
              tagExp = tagExp.substr(0, tagExp.length - 1);
            }
  
            const childNode = new xmlNode(tagName, currentNode, '');
            if(tagName !== tagExp){
              childNode.attrsMap = buildAttributesMap(tagExp, options);
            }
            currentNode.addChild(childNode);
          }else{//opening tag
  
            const childNode = new xmlNode( tagName, currentNode );
            if (options.stopNodes.length && options.stopNodes.includes(childNode.tagname)) {
              childNode.startIndex=closeIndex;
            }
            if(tagName !== tagExp && shouldBuildAttributesMap){
              childNode.attrsMap = buildAttributesMap(tagExp, options);
            }
            currentNode.addChild(childNode);
            currentNode = childNode;
          }
          textData = "";
          i = closeIndex;
        }
      }else{
        textData += xmlData[i];
      }
    }
    return xmlObj;
  }
  
  function closingIndexForOpeningTag(data, i){
    let attrBoundary;
    let tagExp = "";
    for (let index = i; index < data.length; index++) {
      let ch = data[index];
      if (attrBoundary) {
          if (ch === attrBoundary) attrBoundary = "";//reset
      } else if (ch === '"' || ch === "'") {
          attrBoundary = ch;
      } else if (ch === '>') {
          return {
            data: tagExp,
            index: index
          }
      } else if (ch === '\t') {
        ch = " "
      }
      tagExp += ch;
    }
  }
  
  function findClosingIndex(xmlData, str, i, errMsg){
    const closingIndex = xmlData.indexOf(str, i);
    if(closingIndex === -1){
      throw new Error(errMsg)
    }else{
      return closingIndex + str.length - 1;
    }
  }
  
  exports.getTraversalObj = getTraversalObj;
  
  
  /***/ }),
  
  /***/ 5214:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var fs = __nccwpck_require__(5747);
  var util = __nccwpck_require__(1669);
  var stream = __nccwpck_require__(2413);
  var Readable = stream.Readable;
  var Writable = stream.Writable;
  var PassThrough = stream.PassThrough;
  var Pend = __nccwpck_require__(9326);
  var EventEmitter = __nccwpck_require__(8614).EventEmitter;
  
  exports.createFromBuffer = createFromBuffer;
  exports.createFromFd = createFromFd;
  exports.BufferSlicer = BufferSlicer;
  exports.FdSlicer = FdSlicer;
  
  util.inherits(FdSlicer, EventEmitter);
  function FdSlicer(fd, options) {
    options = options || {};
    EventEmitter.call(this);
  
    this.fd = fd;
    this.pend = new Pend();
    this.pend.max = 1;
    this.refCount = 0;
    this.autoClose = !!options.autoClose;
  }
  
  FdSlicer.prototype.read = function(buffer, offset, length, position, callback) {
    var self = this;
    self.pend.go(function(cb) {
      fs.read(self.fd, buffer, offset, length, position, function(err, bytesRead, buffer) {
        cb();
        callback(err, bytesRead, buffer);
      });
    });
  };
  
  FdSlicer.prototype.write = function(buffer, offset, length, position, callback) {
    var self = this;
    self.pend.go(function(cb) {
      fs.write(self.fd, buffer, offset, length, position, function(err, written, buffer) {
        cb();
        callback(err, written, buffer);
      });
    });
  };
  
  FdSlicer.prototype.createReadStream = function(options) {
    return new ReadStream(this, options);
  };
  
  FdSlicer.prototype.createWriteStream = function(options) {
    return new WriteStream(this, options);
  };
  
  FdSlicer.prototype.ref = function() {
    this.refCount += 1;
  };
  
  FdSlicer.prototype.unref = function() {
    var self = this;
    self.refCount -= 1;
  
    if (self.refCount > 0) return;
    if (self.refCount < 0) throw new Error("invalid unref");
  
    if (self.autoClose) {
      fs.close(self.fd, onCloseDone);
    }
  
    function onCloseDone(err) {
      if (err) {
        self.emit('error', err);
      } else {
        self.emit('close');
      }
    }
  };
  
  util.inherits(ReadStream, Readable);
  function ReadStream(context, options) {
    options = options || {};
    Readable.call(this, options);
  
    this.context = context;
    this.context.ref();
  
    this.start = options.start || 0;
    this.endOffset = options.end;
    this.pos = this.start;
    this.destroyed = false;
  }
  
  ReadStream.prototype._read = function(n) {
    var self = this;
    if (self.destroyed) return;
  
    var toRead = Math.min(self._readableState.highWaterMark, n);
    if (self.endOffset != null) {
      toRead = Math.min(toRead, self.endOffset - self.pos);
    }
    if (toRead <= 0) {
      self.destroyed = true;
      self.push(null);
      self.context.unref();
      return;
    }
    self.context.pend.go(function(cb) {
      if (self.destroyed) return cb();
      var buffer = new Buffer(toRead);
      fs.read(self.context.fd, buffer, 0, toRead, self.pos, function(err, bytesRead) {
        if (err) {
          self.destroy(err);
        } else if (bytesRead === 0) {
          self.destroyed = true;
          self.push(null);
          self.context.unref();
        } else {
          self.pos += bytesRead;
          self.push(buffer.slice(0, bytesRead));
        }
        cb();
      });
    });
  };
  
  ReadStream.prototype.destroy = function(err) {
    if (this.destroyed) return;
    err = err || new Error("stream destroyed");
    this.destroyed = true;
    this.emit('error', err);
    this.context.unref();
  };
  
  util.inherits(WriteStream, Writable);
  function WriteStream(context, options) {
    options = options || {};
    Writable.call(this, options);
  
    this.context = context;
    this.context.ref();
  
    this.start = options.start || 0;
    this.endOffset = (options.end == null) ? Infinity : +options.end;
    this.bytesWritten = 0;
    this.pos = this.start;
    this.destroyed = false;
  
    this.on('finish', this.destroy.bind(this));
  }
  
  WriteStream.prototype._write = function(buffer, encoding, callback) {
    var self = this;
    if (self.destroyed) return;
  
    if (self.pos + buffer.length > self.endOffset) {
      var err = new Error("maximum file length exceeded");
      err.code = 'ETOOBIG';
      self.destroy();
      callback(err);
      return;
    }
    self.context.pend.go(function(cb) {
      if (self.destroyed) return cb();
      fs.write(self.context.fd, buffer, 0, buffer.length, self.pos, function(err, bytes) {
        if (err) {
          self.destroy();
          cb();
          callback(err);
        } else {
          self.bytesWritten += bytes;
          self.pos += bytes;
          self.emit('progress');
          cb();
          callback();
        }
      });
    });
  };
  
  WriteStream.prototype.destroy = function() {
    if (this.destroyed) return;
    this.destroyed = true;
    this.context.unref();
  };
  
  util.inherits(BufferSlicer, EventEmitter);
  function BufferSlicer(buffer, options) {
    EventEmitter.call(this);
  
    options = options || {};
    this.refCount = 0;
    this.buffer = buffer;
    this.maxChunkSize = options.maxChunkSize || Number.MAX_SAFE_INTEGER;
  }
  
  BufferSlicer.prototype.read = function(buffer, offset, length, position, callback) {
    var end = position + length;
    var delta = end - this.buffer.length;
    var written = (delta > 0) ? delta : length;
    this.buffer.copy(buffer, offset, position, end);
    setImmediate(function() {
      callback(null, written);
    });
  };
  
  BufferSlicer.prototype.write = function(buffer, offset, length, position, callback) {
    buffer.copy(this.buffer, position, offset, offset + length);
    setImmediate(function() {
      callback(null, length, buffer);
    });
  };
  
  BufferSlicer.prototype.createReadStream = function(options) {
    options = options || {};
    var readStream = new PassThrough(options);
    readStream.destroyed = false;
    readStream.start = options.start || 0;
    readStream.endOffset = options.end;
    // by the time this function returns, we'll be done.
    readStream.pos = readStream.endOffset || this.buffer.length;
  
    // respect the maxChunkSize option to slice up the chunk into smaller pieces.
    var entireSlice = this.buffer.slice(readStream.start, readStream.pos);
    var offset = 0;
    while (true) {
      var nextOffset = offset + this.maxChunkSize;
      if (nextOffset >= entireSlice.length) {
        // last chunk
        if (offset < entireSlice.length) {
          readStream.write(entireSlice.slice(offset, entireSlice.length));
        }
        break;
      }
      readStream.write(entireSlice.slice(offset, nextOffset));
      offset = nextOffset;
    }
  
    readStream.end();
    readStream.destroy = function() {
      readStream.destroyed = true;
    };
    return readStream;
  };
  
  BufferSlicer.prototype.createWriteStream = function(options) {
    var bufferSlicer = this;
    options = options || {};
    var writeStream = new Writable(options);
    writeStream.start = options.start || 0;
    writeStream.endOffset = (options.end == null) ? this.buffer.length : +options.end;
    writeStream.bytesWritten = 0;
    writeStream.pos = writeStream.start;
    writeStream.destroyed = false;
    writeStream._write = function(buffer, encoding, callback) {
      if (writeStream.destroyed) return;
  
      var end = writeStream.pos + buffer.length;
      if (end > writeStream.endOffset) {
        var err = new Error("maximum file length exceeded");
        err.code = 'ETOOBIG';
        writeStream.destroyed = true;
        callback(err);
        return;
      }
      buffer.copy(bufferSlicer.buffer, writeStream.pos, 0, buffer.length);
  
      writeStream.bytesWritten += buffer.length;
      writeStream.pos = end;
      writeStream.emit('progress');
      callback();
    };
    writeStream.destroy = function() {
      writeStream.destroyed = true;
    };
    return writeStream;
  };
  
  BufferSlicer.prototype.ref = function() {
    this.refCount += 1;
  };
  
  BufferSlicer.prototype.unref = function() {
    this.refCount -= 1;
  
    if (this.refCount < 0) {
      throw new Error("invalid unref");
    }
  };
  
  function createFromBuffer(buffer, options) {
    return new BufferSlicer(buffer, options);
  }
  
  function createFromFd(fd, options) {
    return new FdSlicer(fd, options);
  }
  
  
  /***/ }),
  
  /***/ 5488:
  /***/ (function(module, exports, __nccwpck_require__) {
  
  /* module decorator */ module = __nccwpck_require__.nmd(module);
  /*! https://mths.be/he v1.2.0 by @mathias | MIT license */
  ;(function(root) {
  
  	// Detect free variables `exports`.
  	var freeExports =  true && exports;
  
  	// Detect free variable `module`.
  	var freeModule =  true && module &&
  		module.exports == freeExports && module;
  
  	// Detect free variable `global`, from Node.js or Browserified code,
  	// and use it as `root`.
  	var freeGlobal = typeof global == 'object' && global;
  	if (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal) {
  		root = freeGlobal;
  	}
  
  	/*--------------------------------------------------------------------------*/
  
  	// All astral symbols.
  	var regexAstralSymbols = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
  	// All ASCII symbols (not just printable ASCII) except those listed in the
  	// first column of the overrides table.
  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides
  	var regexAsciiWhitelist = /[\x01-\x7F]/g;
  	// All BMP symbols that are not ASCII newlines, printable ASCII symbols, or
  	// code points listed in the first column of the overrides table on
  	// https://html.spec.whatwg.org/multipage/syntax.html#table-charref-overrides.
  	var regexBmpWhitelist = /[\x01-\t\x0B\f\x0E-\x1F\x7F\x81\x8D\x8F\x90\x9D\xA0-\uFFFF]/g;
  
  	var regexEncodeNonAscii = /<\u20D2|=\u20E5|>\u20D2|\u205F\u200A|\u219D\u0338|\u2202\u0338|\u2220\u20D2|\u2229\uFE00|\u222A\uFE00|\u223C\u20D2|\u223D\u0331|\u223E\u0333|\u2242\u0338|\u224B\u0338|\u224D\u20D2|\u224E\u0338|\u224F\u0338|\u2250\u0338|\u2261\u20E5|\u2264\u20D2|\u2265\u20D2|\u2266\u0338|\u2267\u0338|\u2268\uFE00|\u2269\uFE00|\u226A\u0338|\u226A\u20D2|\u226B\u0338|\u226B\u20D2|\u227F\u0338|\u2282\u20D2|\u2283\u20D2|\u228A\uFE00|\u228B\uFE00|\u228F\u0338|\u2290\u0338|\u2293\uFE00|\u2294\uFE00|\u22B4\u20D2|\u22B5\u20D2|\u22D8\u0338|\u22D9\u0338|\u22DA\uFE00|\u22DB\uFE00|\u22F5\u0338|\u22F9\u0338|\u2933\u0338|\u29CF\u0338|\u29D0\u0338|\u2A6D\u0338|\u2A70\u0338|\u2A7D\u0338|\u2A7E\u0338|\u2AA1\u0338|\u2AA2\u0338|\u2AAC\uFE00|\u2AAD\uFE00|\u2AAF\u0338|\u2AB0\u0338|\u2AC5\u0338|\u2AC6\u0338|\u2ACB\uFE00|\u2ACC\uFE00|\u2AFD\u20E5|[\xA0-\u0113\u0116-\u0122\u0124-\u012B\u012E-\u014D\u0150-\u017E\u0192\u01B5\u01F5\u0237\u02C6\u02C7\u02D8-\u02DD\u0311\u0391-\u03A1\u03A3-\u03A9\u03B1-\u03C9\u03D1\u03D2\u03D5\u03D6\u03DC\u03DD\u03F0\u03F1\u03F5\u03F6\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E\u045F\u2002-\u2005\u2007-\u2010\u2013-\u2016\u2018-\u201A\u201C-\u201E\u2020-\u2022\u2025\u2026\u2030-\u2035\u2039\u203A\u203E\u2041\u2043\u2044\u204F\u2057\u205F-\u2063\u20AC\u20DB\u20DC\u2102\u2105\u210A-\u2113\u2115-\u211E\u2122\u2124\u2127-\u2129\u212C\u212D\u212F-\u2131\u2133-\u2138\u2145-\u2148\u2153-\u215E\u2190-\u219B\u219D-\u21A7\u21A9-\u21AE\u21B0-\u21B3\u21B5-\u21B7\u21BA-\u21DB\u21DD\u21E4\u21E5\u21F5\u21FD-\u2205\u2207-\u2209\u220B\u220C\u220F-\u2214\u2216-\u2218\u221A\u221D-\u2238\u223A-\u2257\u2259\u225A\u225C\u225F-\u2262\u2264-\u228B\u228D-\u229B\u229D-\u22A5\u22A7-\u22B0\u22B2-\u22BB\u22BD-\u22DB\u22DE-\u22E3\u22E6-\u22F7\u22F9-\u22FE\u2305\u2306\u2308-\u2310\u2312\u2313\u2315\u2316\u231C-\u231F\u2322\u2323\u232D\u232E\u2336\u233D\u233F\u237C\u23B0\u23B1\u23B4-\u23B6\u23DC-\u23DF\u23E2\u23E7\u2423\u24C8\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2550-\u256C\u2580\u2584\u2588\u2591-\u2593\u25A1\u25AA\u25AB\u25AD\u25AE\u25B1\u25B3-\u25B5\u25B8\u25B9\u25BD-\u25BF\u25C2\u25C3\u25CA\u25CB\u25EC\u25EF\u25F8-\u25FC\u2605\u2606\u260E\u2640\u2642\u2660\u2663\u2665\u2666\u266A\u266D-\u266F\u2713\u2717\u2720\u2736\u2758\u2772\u2773\u27C8\u27C9\u27E6-\u27ED\u27F5-\u27FA\u27FC\u27FF\u2902-\u2905\u290C-\u2913\u2916\u2919-\u2920\u2923-\u292A\u2933\u2935-\u2939\u293C\u293D\u2945\u2948-\u294B\u294E-\u2976\u2978\u2979\u297B-\u297F\u2985\u2986\u298B-\u2996\u299A\u299C\u299D\u29A4-\u29B7\u29B9\u29BB\u29BC\u29BE-\u29C5\u29C9\u29CD-\u29D0\u29DC-\u29DE\u29E3-\u29E5\u29EB\u29F4\u29F6\u2A00-\u2A02\u2A04\u2A06\u2A0C\u2A0D\u2A10-\u2A17\u2A22-\u2A27\u2A29\u2A2A\u2A2D-\u2A31\u2A33-\u2A3C\u2A3F\u2A40\u2A42-\u2A4D\u2A50\u2A53-\u2A58\u2A5A-\u2A5D\u2A5F\u2A66\u2A6A\u2A6D-\u2A75\u2A77-\u2A9A\u2A9D-\u2AA2\u2AA4-\u2AB0\u2AB3-\u2AC8\u2ACB\u2ACC\u2ACF-\u2ADB\u2AE4\u2AE6-\u2AE9\u2AEB-\u2AF3\u2AFD\uFB00-\uFB04]|\uD835[\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDCCF\uDD04\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDD6B]/g;
  	var encodeMap = {'\xAD':'shy','\u200C':'zwnj','\u200D':'zwj','\u200E':'lrm','\u2063':'ic','\u2062':'it','\u2061':'af','\u200F':'rlm','\u200B':'ZeroWidthSpace','\u2060':'NoBreak','\u0311':'DownBreve','\u20DB':'tdot','\u20DC':'DotDot','\t':'Tab','\n':'NewLine','\u2008':'puncsp','\u205F':'MediumSpace','\u2009':'thinsp','\u200A':'hairsp','\u2004':'emsp13','\u2002':'ensp','\u2005':'emsp14','\u2003':'emsp','\u2007':'numsp','\xA0':'nbsp','\u205F\u200A':'ThickSpace','\u203E':'oline','_':'lowbar','\u2010':'dash','\u2013':'ndash','\u2014':'mdash','\u2015':'horbar',',':'comma',';':'semi','\u204F':'bsemi',':':'colon','\u2A74':'Colone','!':'excl','\xA1':'iexcl','?':'quest','\xBF':'iquest','.':'period','\u2025':'nldr','\u2026':'mldr','\xB7':'middot','\'':'apos','\u2018':'lsquo','\u2019':'rsquo','\u201A':'sbquo','\u2039':'lsaquo','\u203A':'rsaquo','"':'quot','\u201C':'ldquo','\u201D':'rdquo','\u201E':'bdquo','\xAB':'laquo','\xBB':'raquo','(':'lpar',')':'rpar','[':'lsqb',']':'rsqb','{':'lcub','}':'rcub','\u2308':'lceil','\u2309':'rceil','\u230A':'lfloor','\u230B':'rfloor','\u2985':'lopar','\u2986':'ropar','\u298B':'lbrke','\u298C':'rbrke','\u298D':'lbrkslu','\u298E':'rbrksld','\u298F':'lbrksld','\u2990':'rbrkslu','\u2991':'langd','\u2992':'rangd','\u2993':'lparlt','\u2994':'rpargt','\u2995':'gtlPar','\u2996':'ltrPar','\u27E6':'lobrk','\u27E7':'robrk','\u27E8':'lang','\u27E9':'rang','\u27EA':'Lang','\u27EB':'Rang','\u27EC':'loang','\u27ED':'roang','\u2772':'lbbrk','\u2773':'rbbrk','\u2016':'Vert','\xA7':'sect','\xB6':'para','@':'commat','*':'ast','/':'sol','undefined':null,'&':'amp','#':'num','%':'percnt','\u2030':'permil','\u2031':'pertenk','\u2020':'dagger','\u2021':'Dagger','\u2022':'bull','\u2043':'hybull','\u2032':'prime','\u2033':'Prime','\u2034':'tprime','\u2057':'qprime','\u2035':'bprime','\u2041':'caret','`':'grave','\xB4':'acute','\u02DC':'tilde','^':'Hat','\xAF':'macr','\u02D8':'breve','\u02D9':'dot','\xA8':'die','\u02DA':'ring','\u02DD':'dblac','\xB8':'cedil','\u02DB':'ogon','\u02C6':'circ','\u02C7':'caron','\xB0':'deg','\xA9':'copy','\xAE':'reg','\u2117':'copysr','\u2118':'wp','\u211E':'rx','\u2127':'mho','\u2129':'iiota','\u2190':'larr','\u219A':'nlarr','\u2192':'rarr','\u219B':'nrarr','\u2191':'uarr','\u2193':'darr','\u2194':'harr','\u21AE':'nharr','\u2195':'varr','\u2196':'nwarr','\u2197':'nearr','\u2198':'searr','\u2199':'swarr','\u219D':'rarrw','\u219D\u0338':'nrarrw','\u219E':'Larr','\u219F':'Uarr','\u21A0':'Rarr','\u21A1':'Darr','\u21A2':'larrtl','\u21A3':'rarrtl','\u21A4':'mapstoleft','\u21A5':'mapstoup','\u21A6':'map','\u21A7':'mapstodown','\u21A9':'larrhk','\u21AA':'rarrhk','\u21AB':'larrlp','\u21AC':'rarrlp','\u21AD':'harrw','\u21B0':'lsh','\u21B1':'rsh','\u21B2':'ldsh','\u21B3':'rdsh','\u21B5':'crarr','\u21B6':'cularr','\u21B7':'curarr','\u21BA':'olarr','\u21BB':'orarr','\u21BC':'lharu','\u21BD':'lhard','\u21BE':'uharr','\u21BF':'uharl','\u21C0':'rharu','\u21C1':'rhard','\u21C2':'dharr','\u21C3':'dharl','\u21C4':'rlarr','\u21C5':'udarr','\u21C6':'lrarr','\u21C7':'llarr','\u21C8':'uuarr','\u21C9':'rrarr','\u21CA':'ddarr','\u21CB':'lrhar','\u21CC':'rlhar','\u21D0':'lArr','\u21CD':'nlArr','\u21D1':'uArr','\u21D2':'rArr','\u21CF':'nrArr','\u21D3':'dArr','\u21D4':'iff','\u21CE':'nhArr','\u21D5':'vArr','\u21D6':'nwArr','\u21D7':'neArr','\u21D8':'seArr','\u21D9':'swArr','\u21DA':'lAarr','\u21DB':'rAarr','\u21DD':'zigrarr','\u21E4':'larrb','\u21E5':'rarrb','\u21F5':'duarr','\u21FD':'loarr','\u21FE':'roarr','\u21FF':'hoarr','\u2200':'forall','\u2201':'comp','\u2202':'part','\u2202\u0338':'npart','\u2203':'exist','\u2204':'nexist','\u2205':'empty','\u2207':'Del','\u2208':'in','\u2209':'notin','\u220B':'ni','\u220C':'notni','\u03F6':'bepsi','\u220F':'prod','\u2210':'coprod','\u2211':'sum','+':'plus','\xB1':'pm','\xF7':'div','\xD7':'times','<':'lt','\u226E':'nlt','<\u20D2':'nvlt','=':'equals','\u2260':'ne','=\u20E5':'bne','\u2A75':'Equal','>':'gt','\u226F':'ngt','>\u20D2':'nvgt','\xAC':'not','|':'vert','\xA6':'brvbar','\u2212':'minus','\u2213':'mp','\u2214':'plusdo','\u2044':'frasl','\u2216':'setmn','\u2217':'lowast','\u2218':'compfn','\u221A':'Sqrt','\u221D':'prop','\u221E':'infin','\u221F':'angrt','\u2220':'ang','\u2220\u20D2':'nang','\u2221':'angmsd','\u2222':'angsph','\u2223':'mid','\u2224':'nmid','\u2225':'par','\u2226':'npar','\u2227':'and','\u2228':'or','\u2229':'cap','\u2229\uFE00':'caps','\u222A':'cup','\u222A\uFE00':'cups','\u222B':'int','\u222C':'Int','\u222D':'tint','\u2A0C':'qint','\u222E':'oint','\u222F':'Conint','\u2230':'Cconint','\u2231':'cwint','\u2232':'cwconint','\u2233':'awconint','\u2234':'there4','\u2235':'becaus','\u2236':'ratio','\u2237':'Colon','\u2238':'minusd','\u223A':'mDDot','\u223B':'homtht','\u223C':'sim','\u2241':'nsim','\u223C\u20D2':'nvsim','\u223D':'bsim','\u223D\u0331':'race','\u223E':'ac','\u223E\u0333':'acE','\u223F':'acd','\u2240':'wr','\u2242':'esim','\u2242\u0338':'nesim','\u2243':'sime','\u2244':'nsime','\u2245':'cong','\u2247':'ncong','\u2246':'simne','\u2248':'ap','\u2249':'nap','\u224A':'ape','\u224B':'apid','\u224B\u0338':'napid','\u224C':'bcong','\u224D':'CupCap','\u226D':'NotCupCap','\u224D\u20D2':'nvap','\u224E':'bump','\u224E\u0338':'nbump','\u224F':'bumpe','\u224F\u0338':'nbumpe','\u2250':'doteq','\u2250\u0338':'nedot','\u2251':'eDot','\u2252':'efDot','\u2253':'erDot','\u2254':'colone','\u2255':'ecolon','\u2256':'ecir','\u2257':'cire','\u2259':'wedgeq','\u225A':'veeeq','\u225C':'trie','\u225F':'equest','\u2261':'equiv','\u2262':'nequiv','\u2261\u20E5':'bnequiv','\u2264':'le','\u2270':'nle','\u2264\u20D2':'nvle','\u2265':'ge','\u2271':'nge','\u2265\u20D2':'nvge','\u2266':'lE','\u2266\u0338':'nlE','\u2267':'gE','\u2267\u0338':'ngE','\u2268\uFE00':'lvnE','\u2268':'lnE','\u2269':'gnE','\u2269\uFE00':'gvnE','\u226A':'ll','\u226A\u0338':'nLtv','\u226A\u20D2':'nLt','\u226B':'gg','\u226B\u0338':'nGtv','\u226B\u20D2':'nGt','\u226C':'twixt','\u2272':'lsim','\u2274':'nlsim','\u2273':'gsim','\u2275':'ngsim','\u2276':'lg','\u2278':'ntlg','\u2277':'gl','\u2279':'ntgl','\u227A':'pr','\u2280':'npr','\u227B':'sc','\u2281':'nsc','\u227C':'prcue','\u22E0':'nprcue','\u227D':'sccue','\u22E1':'nsccue','\u227E':'prsim','\u227F':'scsim','\u227F\u0338':'NotSucceedsTilde','\u2282':'sub','\u2284':'nsub','\u2282\u20D2':'vnsub','\u2283':'sup','\u2285':'nsup','\u2283\u20D2':'vnsup','\u2286':'sube','\u2288':'nsube','\u2287':'supe','\u2289':'nsupe','\u228A\uFE00':'vsubne','\u228A':'subne','\u228B\uFE00':'vsupne','\u228B':'supne','\u228D':'cupdot','\u228E':'uplus','\u228F':'sqsub','\u228F\u0338':'NotSquareSubset','\u2290':'sqsup','\u2290\u0338':'NotSquareSuperset','\u2291':'sqsube','\u22E2':'nsqsube','\u2292':'sqsupe','\u22E3':'nsqsupe','\u2293':'sqcap','\u2293\uFE00':'sqcaps','\u2294':'sqcup','\u2294\uFE00':'sqcups','\u2295':'oplus','\u2296':'ominus','\u2297':'otimes','\u2298':'osol','\u2299':'odot','\u229A':'ocir','\u229B':'oast','\u229D':'odash','\u229E':'plusb','\u229F':'minusb','\u22A0':'timesb','\u22A1':'sdotb','\u22A2':'vdash','\u22AC':'nvdash','\u22A3':'dashv','\u22A4':'top','\u22A5':'bot','\u22A7':'models','\u22A8':'vDash','\u22AD':'nvDash','\u22A9':'Vdash','\u22AE':'nVdash','\u22AA':'Vvdash','\u22AB':'VDash','\u22AF':'nVDash','\u22B0':'prurel','\u22B2':'vltri','\u22EA':'nltri','\u22B3':'vrtri','\u22EB':'nrtri','\u22B4':'ltrie','\u22EC':'nltrie','\u22B4\u20D2':'nvltrie','\u22B5':'rtrie','\u22ED':'nrtrie','\u22B5\u20D2':'nvrtrie','\u22B6':'origof','\u22B7':'imof','\u22B8':'mumap','\u22B9':'hercon','\u22BA':'intcal','\u22BB':'veebar','\u22BD':'barvee','\u22BE':'angrtvb','\u22BF':'lrtri','\u22C0':'Wedge','\u22C1':'Vee','\u22C2':'xcap','\u22C3':'xcup','\u22C4':'diam','\u22C5':'sdot','\u22C6':'Star','\u22C7':'divonx','\u22C8':'bowtie','\u22C9':'ltimes','\u22CA':'rtimes','\u22CB':'lthree','\u22CC':'rthree','\u22CD':'bsime','\u22CE':'cuvee','\u22CF':'cuwed','\u22D0':'Sub','\u22D1':'Sup','\u22D2':'Cap','\u22D3':'Cup','\u22D4':'fork','\u22D5':'epar','\u22D6':'ltdot','\u22D7':'gtdot','\u22D8':'Ll','\u22D8\u0338':'nLl','\u22D9':'Gg','\u22D9\u0338':'nGg','\u22DA\uFE00':'lesg','\u22DA':'leg','\u22DB':'gel','\u22DB\uFE00':'gesl','\u22DE':'cuepr','\u22DF':'cuesc','\u22E6':'lnsim','\u22E7':'gnsim','\u22E8':'prnsim','\u22E9':'scnsim','\u22EE':'vellip','\u22EF':'ctdot','\u22F0':'utdot','\u22F1':'dtdot','\u22F2':'disin','\u22F3':'isinsv','\u22F4':'isins','\u22F5':'isindot','\u22F5\u0338':'notindot','\u22F6':'notinvc','\u22F7':'notinvb','\u22F9':'isinE','\u22F9\u0338':'notinE','\u22FA':'nisd','\u22FB':'xnis','\u22FC':'nis','\u22FD':'notnivc','\u22FE':'notnivb','\u2305':'barwed','\u2306':'Barwed','\u230C':'drcrop','\u230D':'dlcrop','\u230E':'urcrop','\u230F':'ulcrop','\u2310':'bnot','\u2312':'profline','\u2313':'profsurf','\u2315':'telrec','\u2316':'target','\u231C':'ulcorn','\u231D':'urcorn','\u231E':'dlcorn','\u231F':'drcorn','\u2322':'frown','\u2323':'smile','\u232D':'cylcty','\u232E':'profalar','\u2336':'topbot','\u233D':'ovbar','\u233F':'solbar','\u237C':'angzarr','\u23B0':'lmoust','\u23B1':'rmoust','\u23B4':'tbrk','\u23B5':'bbrk','\u23B6':'bbrktbrk','\u23DC':'OverParenthesis','\u23DD':'UnderParenthesis','\u23DE':'OverBrace','\u23DF':'UnderBrace','\u23E2':'trpezium','\u23E7':'elinters','\u2423':'blank','\u2500':'boxh','\u2502':'boxv','\u250C':'boxdr','\u2510':'boxdl','\u2514':'boxur','\u2518':'boxul','\u251C':'boxvr','\u2524':'boxvl','\u252C':'boxhd','\u2534':'boxhu','\u253C':'boxvh','\u2550':'boxH','\u2551':'boxV','\u2552':'boxdR','\u2553':'boxDr','\u2554':'boxDR','\u2555':'boxdL','\u2556':'boxDl','\u2557':'boxDL','\u2558':'boxuR','\u2559':'boxUr','\u255A':'boxUR','\u255B':'boxuL','\u255C':'boxUl','\u255D':'boxUL','\u255E':'boxvR','\u255F':'boxVr','\u2560':'boxVR','\u2561':'boxvL','\u2562':'boxVl','\u2563':'boxVL','\u2564':'boxHd','\u2565':'boxhD','\u2566':'boxHD','\u2567':'boxHu','\u2568':'boxhU','\u2569':'boxHU','\u256A':'boxvH','\u256B':'boxVh','\u256C':'boxVH','\u2580':'uhblk','\u2584':'lhblk','\u2588':'block','\u2591':'blk14','\u2592':'blk12','\u2593':'blk34','\u25A1':'squ','\u25AA':'squf','\u25AB':'EmptyVerySmallSquare','\u25AD':'rect','\u25AE':'marker','\u25B1':'fltns','\u25B3':'xutri','\u25B4':'utrif','\u25B5':'utri','\u25B8':'rtrif','\u25B9':'rtri','\u25BD':'xdtri','\u25BE':'dtrif','\u25BF':'dtri','\u25C2':'ltrif','\u25C3':'ltri','\u25CA':'loz','\u25CB':'cir','\u25EC':'tridot','\u25EF':'xcirc','\u25F8':'ultri','\u25F9':'urtri','\u25FA':'lltri','\u25FB':'EmptySmallSquare','\u25FC':'FilledSmallSquare','\u2605':'starf','\u2606':'star','\u260E':'phone','\u2640':'female','\u2642':'male','\u2660':'spades','\u2663':'clubs','\u2665':'hearts','\u2666':'diams','\u266A':'sung','\u2713':'check','\u2717':'cross','\u2720':'malt','\u2736':'sext','\u2758':'VerticalSeparator','\u27C8':'bsolhsub','\u27C9':'suphsol','\u27F5':'xlarr','\u27F6':'xrarr','\u27F7':'xharr','\u27F8':'xlArr','\u27F9':'xrArr','\u27FA':'xhArr','\u27FC':'xmap','\u27FF':'dzigrarr','\u2902':'nvlArr','\u2903':'nvrArr','\u2904':'nvHarr','\u2905':'Map','\u290C':'lbarr','\u290D':'rbarr','\u290E':'lBarr','\u290F':'rBarr','\u2910':'RBarr','\u2911':'DDotrahd','\u2912':'UpArrowBar','\u2913':'DownArrowBar','\u2916':'Rarrtl','\u2919':'latail','\u291A':'ratail','\u291B':'lAtail','\u291C':'rAtail','\u291D':'larrfs','\u291E':'rarrfs','\u291F':'larrbfs','\u2920':'rarrbfs','\u2923':'nwarhk','\u2924':'nearhk','\u2925':'searhk','\u2926':'swarhk','\u2927':'nwnear','\u2928':'toea','\u2929':'tosa','\u292A':'swnwar','\u2933':'rarrc','\u2933\u0338':'nrarrc','\u2935':'cudarrr','\u2936':'ldca','\u2937':'rdca','\u2938':'cudarrl','\u2939':'larrpl','\u293C':'curarrm','\u293D':'cularrp','\u2945':'rarrpl','\u2948':'harrcir','\u2949':'Uarrocir','\u294A':'lurdshar','\u294B':'ldrushar','\u294E':'LeftRightVector','\u294F':'RightUpDownVector','\u2950':'DownLeftRightVector','\u2951':'LeftUpDownVector','\u2952':'LeftVectorBar','\u2953':'RightVectorBar','\u2954':'RightUpVectorBar','\u2955':'RightDownVectorBar','\u2956':'DownLeftVectorBar','\u2957':'DownRightVectorBar','\u2958':'LeftUpVectorBar','\u2959':'LeftDownVectorBar','\u295A':'LeftTeeVector','\u295B':'RightTeeVector','\u295C':'RightUpTeeVector','\u295D':'RightDownTeeVector','\u295E':'DownLeftTeeVector','\u295F':'DownRightTeeVector','\u2960':'LeftUpTeeVector','\u2961':'LeftDownTeeVector','\u2962':'lHar','\u2963':'uHar','\u2964':'rHar','\u2965':'dHar','\u2966':'luruhar','\u2967':'ldrdhar','\u2968':'ruluhar','\u2969':'rdldhar','\u296A':'lharul','\u296B':'llhard','\u296C':'rharul','\u296D':'lrhard','\u296E':'udhar','\u296F':'duhar','\u2970':'RoundImplies','\u2971':'erarr','\u2972':'simrarr','\u2973':'larrsim','\u2974':'rarrsim','\u2975':'rarrap','\u2976':'ltlarr','\u2978':'gtrarr','\u2979':'subrarr','\u297B':'suplarr','\u297C':'lfisht','\u297D':'rfisht','\u297E':'ufisht','\u297F':'dfisht','\u299A':'vzigzag','\u299C':'vangrt','\u299D':'angrtvbd','\u29A4':'ange','\u29A5':'range','\u29A6':'dwangle','\u29A7':'uwangle','\u29A8':'angmsdaa','\u29A9':'angmsdab','\u29AA':'angmsdac','\u29AB':'angmsdad','\u29AC':'angmsdae','\u29AD':'angmsdaf','\u29AE':'angmsdag','\u29AF':'angmsdah','\u29B0':'bemptyv','\u29B1':'demptyv','\u29B2':'cemptyv','\u29B3':'raemptyv','\u29B4':'laemptyv','\u29B5':'ohbar','\u29B6':'omid','\u29B7':'opar','\u29B9':'operp','\u29BB':'olcross','\u29BC':'odsold','\u29BE':'olcir','\u29BF':'ofcir','\u29C0':'olt','\u29C1':'ogt','\u29C2':'cirscir','\u29C3':'cirE','\u29C4':'solb','\u29C5':'bsolb','\u29C9':'boxbox','\u29CD':'trisb','\u29CE':'rtriltri','\u29CF':'LeftTriangleBar','\u29CF\u0338':'NotLeftTriangleBar','\u29D0':'RightTriangleBar','\u29D0\u0338':'NotRightTriangleBar','\u29DC':'iinfin','\u29DD':'infintie','\u29DE':'nvinfin','\u29E3':'eparsl','\u29E4':'smeparsl','\u29E5':'eqvparsl','\u29EB':'lozf','\u29F4':'RuleDelayed','\u29F6':'dsol','\u2A00':'xodot','\u2A01':'xoplus','\u2A02':'xotime','\u2A04':'xuplus','\u2A06':'xsqcup','\u2A0D':'fpartint','\u2A10':'cirfnint','\u2A11':'awint','\u2A12':'rppolint','\u2A13':'scpolint','\u2A14':'npolint','\u2A15':'pointint','\u2A16':'quatint','\u2A17':'intlarhk','\u2A22':'pluscir','\u2A23':'plusacir','\u2A24':'simplus','\u2A25':'plusdu','\u2A26':'plussim','\u2A27':'plustwo','\u2A29':'mcomma','\u2A2A':'minusdu','\u2A2D':'loplus','\u2A2E':'roplus','\u2A2F':'Cross','\u2A30':'timesd','\u2A31':'timesbar','\u2A33':'smashp','\u2A34':'lotimes','\u2A35':'rotimes','\u2A36':'otimesas','\u2A37':'Otimes','\u2A38':'odiv','\u2A39':'triplus','\u2A3A':'triminus','\u2A3B':'tritime','\u2A3C':'iprod','\u2A3F':'amalg','\u2A40':'capdot','\u2A42':'ncup','\u2A43':'ncap','\u2A44':'capand','\u2A45':'cupor','\u2A46':'cupcap','\u2A47':'capcup','\u2A48':'cupbrcap','\u2A49':'capbrcup','\u2A4A':'cupcup','\u2A4B':'capcap','\u2A4C':'ccups','\u2A4D':'ccaps','\u2A50':'ccupssm','\u2A53':'And','\u2A54':'Or','\u2A55':'andand','\u2A56':'oror','\u2A57':'orslope','\u2A58':'andslope','\u2A5A':'andv','\u2A5B':'orv','\u2A5C':'andd','\u2A5D':'ord','\u2A5F':'wedbar','\u2A66':'sdote','\u2A6A':'simdot','\u2A6D':'congdot','\u2A6D\u0338':'ncongdot','\u2A6E':'easter','\u2A6F':'apacir','\u2A70':'apE','\u2A70\u0338':'napE','\u2A71':'eplus','\u2A72':'pluse','\u2A73':'Esim','\u2A77':'eDDot','\u2A78':'equivDD','\u2A79':'ltcir','\u2A7A':'gtcir','\u2A7B':'ltquest','\u2A7C':'gtquest','\u2A7D':'les','\u2A7D\u0338':'nles','\u2A7E':'ges','\u2A7E\u0338':'nges','\u2A7F':'lesdot','\u2A80':'gesdot','\u2A81':'lesdoto','\u2A82':'gesdoto','\u2A83':'lesdotor','\u2A84':'gesdotol','\u2A85':'lap','\u2A86':'gap','\u2A87':'lne','\u2A88':'gne','\u2A89':'lnap','\u2A8A':'gnap','\u2A8B':'lEg','\u2A8C':'gEl','\u2A8D':'lsime','\u2A8E':'gsime','\u2A8F':'lsimg','\u2A90':'gsiml','\u2A91':'lgE','\u2A92':'glE','\u2A93':'lesges','\u2A94':'gesles','\u2A95':'els','\u2A96':'egs','\u2A97':'elsdot','\u2A98':'egsdot','\u2A99':'el','\u2A9A':'eg','\u2A9D':'siml','\u2A9E':'simg','\u2A9F':'simlE','\u2AA0':'simgE','\u2AA1':'LessLess','\u2AA1\u0338':'NotNestedLessLess','\u2AA2':'GreaterGreater','\u2AA2\u0338':'NotNestedGreaterGreater','\u2AA4':'glj','\u2AA5':'gla','\u2AA6':'ltcc','\u2AA7':'gtcc','\u2AA8':'lescc','\u2AA9':'gescc','\u2AAA':'smt','\u2AAB':'lat','\u2AAC':'smte','\u2AAC\uFE00':'smtes','\u2AAD':'late','\u2AAD\uFE00':'lates','\u2AAE':'bumpE','\u2AAF':'pre','\u2AAF\u0338':'npre','\u2AB0':'sce','\u2AB0\u0338':'nsce','\u2AB3':'prE','\u2AB4':'scE','\u2AB5':'prnE','\u2AB6':'scnE','\u2AB7':'prap','\u2AB8':'scap','\u2AB9':'prnap','\u2ABA':'scnap','\u2ABB':'Pr','\u2ABC':'Sc','\u2ABD':'subdot','\u2ABE':'supdot','\u2ABF':'subplus','\u2AC0':'supplus','\u2AC1':'submult','\u2AC2':'supmult','\u2AC3':'subedot','\u2AC4':'supedot','\u2AC5':'subE','\u2AC5\u0338':'nsubE','\u2AC6':'supE','\u2AC6\u0338':'nsupE','\u2AC7':'subsim','\u2AC8':'supsim','\u2ACB\uFE00':'vsubnE','\u2ACB':'subnE','\u2ACC\uFE00':'vsupnE','\u2ACC':'supnE','\u2ACF':'csub','\u2AD0':'csup','\u2AD1':'csube','\u2AD2':'csupe','\u2AD3':'subsup','\u2AD4':'supsub','\u2AD5':'subsub','\u2AD6':'supsup','\u2AD7':'suphsub','\u2AD8':'supdsub','\u2AD9':'forkv','\u2ADA':'topfork','\u2ADB':'mlcp','\u2AE4':'Dashv','\u2AE6':'Vdashl','\u2AE7':'Barv','\u2AE8':'vBar','\u2AE9':'vBarv','\u2AEB':'Vbar','\u2AEC':'Not','\u2AED':'bNot','\u2AEE':'rnmid','\u2AEF':'cirmid','\u2AF0':'midcir','\u2AF1':'topcir','\u2AF2':'nhpar','\u2AF3':'parsim','\u2AFD':'parsl','\u2AFD\u20E5':'nparsl','\u266D':'flat','\u266E':'natur','\u266F':'sharp','\xA4':'curren','\xA2':'cent','$':'dollar','\xA3':'pound','\xA5':'yen','\u20AC':'euro','\xB9':'sup1','\xBD':'half','\u2153':'frac13','\xBC':'frac14','\u2155':'frac15','\u2159':'frac16','\u215B':'frac18','\xB2':'sup2','\u2154':'frac23','\u2156':'frac25','\xB3':'sup3','\xBE':'frac34','\u2157':'frac35','\u215C':'frac38','\u2158':'frac45','\u215A':'frac56','\u215D':'frac58','\u215E':'frac78','\uD835\uDCB6':'ascr','\uD835\uDD52':'aopf','\uD835\uDD1E':'afr','\uD835\uDD38':'Aopf','\uD835\uDD04':'Afr','\uD835\uDC9C':'Ascr','\xAA':'ordf','\xE1':'aacute','\xC1':'Aacute','\xE0':'agrave','\xC0':'Agrave','\u0103':'abreve','\u0102':'Abreve','\xE2':'acirc','\xC2':'Acirc','\xE5':'aring','\xC5':'angst','\xE4':'auml','\xC4':'Auml','\xE3':'atilde','\xC3':'Atilde','\u0105':'aogon','\u0104':'Aogon','\u0101':'amacr','\u0100':'Amacr','\xE6':'aelig','\xC6':'AElig','\uD835\uDCB7':'bscr','\uD835\uDD53':'bopf','\uD835\uDD1F':'bfr','\uD835\uDD39':'Bopf','\u212C':'Bscr','\uD835\uDD05':'Bfr','\uD835\uDD20':'cfr','\uD835\uDCB8':'cscr','\uD835\uDD54':'copf','\u212D':'Cfr','\uD835\uDC9E':'Cscr','\u2102':'Copf','\u0107':'cacute','\u0106':'Cacute','\u0109':'ccirc','\u0108':'Ccirc','\u010D':'ccaron','\u010C':'Ccaron','\u010B':'cdot','\u010A':'Cdot','\xE7':'ccedil','\xC7':'Ccedil','\u2105':'incare','\uD835\uDD21':'dfr','\u2146':'dd','\uD835\uDD55':'dopf','\uD835\uDCB9':'dscr','\uD835\uDC9F':'Dscr','\uD835\uDD07':'Dfr','\u2145':'DD','\uD835\uDD3B':'Dopf','\u010F':'dcaron','\u010E':'Dcaron','\u0111':'dstrok','\u0110':'Dstrok','\xF0':'eth','\xD0':'ETH','\u2147':'ee','\u212F':'escr','\uD835\uDD22':'efr','\uD835\uDD56':'eopf','\u2130':'Escr','\uD835\uDD08':'Efr','\uD835\uDD3C':'Eopf','\xE9':'eacute','\xC9':'Eacute','\xE8':'egrave','\xC8':'Egrave','\xEA':'ecirc','\xCA':'Ecirc','\u011B':'ecaron','\u011A':'Ecaron','\xEB':'euml','\xCB':'Euml','\u0117':'edot','\u0116':'Edot','\u0119':'eogon','\u0118':'Eogon','\u0113':'emacr','\u0112':'Emacr','\uD835\uDD23':'ffr','\uD835\uDD57':'fopf','\uD835\uDCBB':'fscr','\uD835\uDD09':'Ffr','\uD835\uDD3D':'Fopf','\u2131':'Fscr','\uFB00':'fflig','\uFB03':'ffilig','\uFB04':'ffllig','\uFB01':'filig','fj':'fjlig','\uFB02':'fllig','\u0192':'fnof','\u210A':'gscr','\uD835\uDD58':'gopf','\uD835\uDD24':'gfr','\uD835\uDCA2':'Gscr','\uD835\uDD3E':'Gopf','\uD835\uDD0A':'Gfr','\u01F5':'gacute','\u011F':'gbreve','\u011E':'Gbreve','\u011D':'gcirc','\u011C':'Gcirc','\u0121':'gdot','\u0120':'Gdot','\u0122':'Gcedil','\uD835\uDD25':'hfr','\u210E':'planckh','\uD835\uDCBD':'hscr','\uD835\uDD59':'hopf','\u210B':'Hscr','\u210C':'Hfr','\u210D':'Hopf','\u0125':'hcirc','\u0124':'Hcirc','\u210F':'hbar','\u0127':'hstrok','\u0126':'Hstrok','\uD835\uDD5A':'iopf','\uD835\uDD26':'ifr','\uD835\uDCBE':'iscr','\u2148':'ii','\uD835\uDD40':'Iopf','\u2110':'Iscr','\u2111':'Im','\xED':'iacute','\xCD':'Iacute','\xEC':'igrave','\xCC':'Igrave','\xEE':'icirc','\xCE':'Icirc','\xEF':'iuml','\xCF':'Iuml','\u0129':'itilde','\u0128':'Itilde','\u0130':'Idot','\u012F':'iogon','\u012E':'Iogon','\u012B':'imacr','\u012A':'Imacr','\u0133':'ijlig','\u0132':'IJlig','\u0131':'imath','\uD835\uDCBF':'jscr','\uD835\uDD5B':'jopf','\uD835\uDD27':'jfr','\uD835\uDCA5':'Jscr','\uD835\uDD0D':'Jfr','\uD835\uDD41':'Jopf','\u0135':'jcirc','\u0134':'Jcirc','\u0237':'jmath','\uD835\uDD5C':'kopf','\uD835\uDCC0':'kscr','\uD835\uDD28':'kfr','\uD835\uDCA6':'Kscr','\uD835\uDD42':'Kopf','\uD835\uDD0E':'Kfr','\u0137':'kcedil','\u0136':'Kcedil','\uD835\uDD29':'lfr','\uD835\uDCC1':'lscr','\u2113':'ell','\uD835\uDD5D':'lopf','\u2112':'Lscr','\uD835\uDD0F':'Lfr','\uD835\uDD43':'Lopf','\u013A':'lacute','\u0139':'Lacute','\u013E':'lcaron','\u013D':'Lcaron','\u013C':'lcedil','\u013B':'Lcedil','\u0142':'lstrok','\u0141':'Lstrok','\u0140':'lmidot','\u013F':'Lmidot','\uD835\uDD2A':'mfr','\uD835\uDD5E':'mopf','\uD835\uDCC2':'mscr','\uD835\uDD10':'Mfr','\uD835\uDD44':'Mopf','\u2133':'Mscr','\uD835\uDD2B':'nfr','\uD835\uDD5F':'nopf','\uD835\uDCC3':'nscr','\u2115':'Nopf','\uD835\uDCA9':'Nscr','\uD835\uDD11':'Nfr','\u0144':'nacute','\u0143':'Nacute','\u0148':'ncaron','\u0147':'Ncaron','\xF1':'ntilde','\xD1':'Ntilde','\u0146':'ncedil','\u0145':'Ncedil','\u2116':'numero','\u014B':'eng','\u014A':'ENG','\uD835\uDD60':'oopf','\uD835\uDD2C':'ofr','\u2134':'oscr','\uD835\uDCAA':'Oscr','\uD835\uDD12':'Ofr','\uD835\uDD46':'Oopf','\xBA':'ordm','\xF3':'oacute','\xD3':'Oacute','\xF2':'ograve','\xD2':'Ograve','\xF4':'ocirc','\xD4':'Ocirc','\xF6':'ouml','\xD6':'Ouml','\u0151':'odblac','\u0150':'Odblac','\xF5':'otilde','\xD5':'Otilde','\xF8':'oslash','\xD8':'Oslash','\u014D':'omacr','\u014C':'Omacr','\u0153':'oelig','\u0152':'OElig','\uD835\uDD2D':'pfr','\uD835\uDCC5':'pscr','\uD835\uDD61':'popf','\u2119':'Popf','\uD835\uDD13':'Pfr','\uD835\uDCAB':'Pscr','\uD835\uDD62':'qopf','\uD835\uDD2E':'qfr','\uD835\uDCC6':'qscr','\uD835\uDCAC':'Qscr','\uD835\uDD14':'Qfr','\u211A':'Qopf','\u0138':'kgreen','\uD835\uDD2F':'rfr','\uD835\uDD63':'ropf','\uD835\uDCC7':'rscr','\u211B':'Rscr','\u211C':'Re','\u211D':'Ropf','\u0155':'racute','\u0154':'Racute','\u0159':'rcaron','\u0158':'Rcaron','\u0157':'rcedil','\u0156':'Rcedil','\uD835\uDD64':'sopf','\uD835\uDCC8':'sscr','\uD835\uDD30':'sfr','\uD835\uDD4A':'Sopf','\uD835\uDD16':'Sfr','\uD835\uDCAE':'Sscr','\u24C8':'oS','\u015B':'sacute','\u015A':'Sacute','\u015D':'scirc','\u015C':'Scirc','\u0161':'scaron','\u0160':'Scaron','\u015F':'scedil','\u015E':'Scedil','\xDF':'szlig','\uD835\uDD31':'tfr','\uD835\uDCC9':'tscr','\uD835\uDD65':'topf','\uD835\uDCAF':'Tscr','\uD835\uDD17':'Tfr','\uD835\uDD4B':'Topf','\u0165':'tcaron','\u0164':'Tcaron','\u0163':'tcedil','\u0162':'Tcedil','\u2122':'trade','\u0167':'tstrok','\u0166':'Tstrok','\uD835\uDCCA':'uscr','\uD835\uDD66':'uopf','\uD835\uDD32':'ufr','\uD835\uDD4C':'Uopf','\uD835\uDD18':'Ufr','\uD835\uDCB0':'Uscr','\xFA':'uacute','\xDA':'Uacute','\xF9':'ugrave','\xD9':'Ugrave','\u016D':'ubreve','\u016C':'Ubreve','\xFB':'ucirc','\xDB':'Ucirc','\u016F':'uring','\u016E':'Uring','\xFC':'uuml','\xDC':'Uuml','\u0171':'udblac','\u0170':'Udblac','\u0169':'utilde','\u0168':'Utilde','\u0173':'uogon','\u0172':'Uogon','\u016B':'umacr','\u016A':'Umacr','\uD835\uDD33':'vfr','\uD835\uDD67':'vopf','\uD835\uDCCB':'vscr','\uD835\uDD19':'Vfr','\uD835\uDD4D':'Vopf','\uD835\uDCB1':'Vscr','\uD835\uDD68':'wopf','\uD835\uDCCC':'wscr','\uD835\uDD34':'wfr','\uD835\uDCB2':'Wscr','\uD835\uDD4E':'Wopf','\uD835\uDD1A':'Wfr','\u0175':'wcirc','\u0174':'Wcirc','\uD835\uDD35':'xfr','\uD835\uDCCD':'xscr','\uD835\uDD69':'xopf','\uD835\uDD4F':'Xopf','\uD835\uDD1B':'Xfr','\uD835\uDCB3':'Xscr','\uD835\uDD36':'yfr','\uD835\uDCCE':'yscr','\uD835\uDD6A':'yopf','\uD835\uDCB4':'Yscr','\uD835\uDD1C':'Yfr','\uD835\uDD50':'Yopf','\xFD':'yacute','\xDD':'Yacute','\u0177':'ycirc','\u0176':'Ycirc','\xFF':'yuml','\u0178':'Yuml','\uD835\uDCCF':'zscr','\uD835\uDD37':'zfr','\uD835\uDD6B':'zopf','\u2128':'Zfr','\u2124':'Zopf','\uD835\uDCB5':'Zscr','\u017A':'zacute','\u0179':'Zacute','\u017E':'zcaron','\u017D':'Zcaron','\u017C':'zdot','\u017B':'Zdot','\u01B5':'imped','\xFE':'thorn','\xDE':'THORN','\u0149':'napos','\u03B1':'alpha','\u0391':'Alpha','\u03B2':'beta','\u0392':'Beta','\u03B3':'gamma','\u0393':'Gamma','\u03B4':'delta','\u0394':'Delta','\u03B5':'epsi','\u03F5':'epsiv','\u0395':'Epsilon','\u03DD':'gammad','\u03DC':'Gammad','\u03B6':'zeta','\u0396':'Zeta','\u03B7':'eta','\u0397':'Eta','\u03B8':'theta','\u03D1':'thetav','\u0398':'Theta','\u03B9':'iota','\u0399':'Iota','\u03BA':'kappa','\u03F0':'kappav','\u039A':'Kappa','\u03BB':'lambda','\u039B':'Lambda','\u03BC':'mu','\xB5':'micro','\u039C':'Mu','\u03BD':'nu','\u039D':'Nu','\u03BE':'xi','\u039E':'Xi','\u03BF':'omicron','\u039F':'Omicron','\u03C0':'pi','\u03D6':'piv','\u03A0':'Pi','\u03C1':'rho','\u03F1':'rhov','\u03A1':'Rho','\u03C3':'sigma','\u03A3':'Sigma','\u03C2':'sigmaf','\u03C4':'tau','\u03A4':'Tau','\u03C5':'upsi','\u03A5':'Upsilon','\u03D2':'Upsi','\u03C6':'phi','\u03D5':'phiv','\u03A6':'Phi','\u03C7':'chi','\u03A7':'Chi','\u03C8':'psi','\u03A8':'Psi','\u03C9':'omega','\u03A9':'ohm','\u0430':'acy','\u0410':'Acy','\u0431':'bcy','\u0411':'Bcy','\u0432':'vcy','\u0412':'Vcy','\u0433':'gcy','\u0413':'Gcy','\u0453':'gjcy','\u0403':'GJcy','\u0434':'dcy','\u0414':'Dcy','\u0452':'djcy','\u0402':'DJcy','\u0435':'iecy','\u0415':'IEcy','\u0451':'iocy','\u0401':'IOcy','\u0454':'jukcy','\u0404':'Jukcy','\u0436':'zhcy','\u0416':'ZHcy','\u0437':'zcy','\u0417':'Zcy','\u0455':'dscy','\u0405':'DScy','\u0438':'icy','\u0418':'Icy','\u0456':'iukcy','\u0406':'Iukcy','\u0457':'yicy','\u0407':'YIcy','\u0439':'jcy','\u0419':'Jcy','\u0458':'jsercy','\u0408':'Jsercy','\u043A':'kcy','\u041A':'Kcy','\u045C':'kjcy','\u040C':'KJcy','\u043B':'lcy','\u041B':'Lcy','\u0459':'ljcy','\u0409':'LJcy','\u043C':'mcy','\u041C':'Mcy','\u043D':'ncy','\u041D':'Ncy','\u045A':'njcy','\u040A':'NJcy','\u043E':'ocy','\u041E':'Ocy','\u043F':'pcy','\u041F':'Pcy','\u0440':'rcy','\u0420':'Rcy','\u0441':'scy','\u0421':'Scy','\u0442':'tcy','\u0422':'Tcy','\u045B':'tshcy','\u040B':'TSHcy','\u0443':'ucy','\u0423':'Ucy','\u045E':'ubrcy','\u040E':'Ubrcy','\u0444':'fcy','\u0424':'Fcy','\u0445':'khcy','\u0425':'KHcy','\u0446':'tscy','\u0426':'TScy','\u0447':'chcy','\u0427':'CHcy','\u045F':'dzcy','\u040F':'DZcy','\u0448':'shcy','\u0428':'SHcy','\u0449':'shchcy','\u0429':'SHCHcy','\u044A':'hardcy','\u042A':'HARDcy','\u044B':'ycy','\u042B':'Ycy','\u044C':'softcy','\u042C':'SOFTcy','\u044D':'ecy','\u042D':'Ecy','\u044E':'yucy','\u042E':'YUcy','\u044F':'yacy','\u042F':'YAcy','\u2135':'aleph','\u2136':'beth','\u2137':'gimel','\u2138':'daleth'};
  
  	var regexEscape = /["&'<>`]/g;
  	var escapeMap = {
  		'"': '&quot;',
  		'&': '&amp;',
  		'\'': '&#x27;',
  		'<': '&lt;',
  		// See https://mathiasbynens.be/notes/ambiguous-ampersands: in HTML, the
  		// following is not strictly necessary unless it’s part of a tag or an
  		// unquoted attribute value. We’re only escaping it to support those
  		// situations, and for XML support.
  		'>': '&gt;',
  		// In Internet Explorer ≤ 8, the backtick character can be used
  		// to break out of (un)quoted attribute values or HTML comments.
  		// See http://html5sec.org/#102, http://html5sec.org/#108, and
  		// http://html5sec.org/#133.
  		'`': '&#x60;'
  	};
  
  	var regexInvalidEntity = /&#(?:[xX][^a-fA-F0-9]|[^0-9xX])/;
  	var regexInvalidRawCodePoint = /[\0-\x08\x0B\x0E-\x1F\x7F-\x9F\uFDD0-\uFDEF\uFFFE\uFFFF]|[\uD83F\uD87F\uD8BF\uD8FF\uD93F\uD97F\uD9BF\uD9FF\uDA3F\uDA7F\uDABF\uDAFF\uDB3F\uDB7F\uDBBF\uDBFF][\uDFFE\uDFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/;
  	var regexDecode = /&(CounterClockwiseContourIntegral|DoubleLongLeftRightArrow|ClockwiseContourIntegral|NotNestedGreaterGreater|NotSquareSupersetEqual|DiacriticalDoubleAcute|NotRightTriangleEqual|NotSucceedsSlantEqual|NotPrecedesSlantEqual|CloseCurlyDoubleQuote|NegativeVeryThinSpace|DoubleContourIntegral|FilledVerySmallSquare|CapitalDifferentialD|OpenCurlyDoubleQuote|EmptyVerySmallSquare|NestedGreaterGreater|DoubleLongRightArrow|NotLeftTriangleEqual|NotGreaterSlantEqual|ReverseUpEquilibrium|DoubleLeftRightArrow|NotSquareSubsetEqual|NotDoubleVerticalBar|RightArrowLeftArrow|NotGreaterFullEqual|NotRightTriangleBar|SquareSupersetEqual|DownLeftRightVector|DoubleLongLeftArrow|leftrightsquigarrow|LeftArrowRightArrow|NegativeMediumSpace|blacktriangleright|RightDownVectorBar|PrecedesSlantEqual|RightDoubleBracket|SucceedsSlantEqual|NotLeftTriangleBar|RightTriangleEqual|SquareIntersection|RightDownTeeVector|ReverseEquilibrium|NegativeThickSpace|longleftrightarrow|Longleftrightarrow|LongLeftRightArrow|DownRightTeeVector|DownRightVectorBar|GreaterSlantEqual|SquareSubsetEqual|LeftDownVectorBar|LeftDoubleBracket|VerticalSeparator|rightleftharpoons|NotGreaterGreater|NotSquareSuperset|blacktriangleleft|blacktriangledown|NegativeThinSpace|LeftDownTeeVector|NotLessSlantEqual|leftrightharpoons|DoubleUpDownArrow|DoubleVerticalBar|LeftTriangleEqual|FilledSmallSquare|twoheadrightarrow|NotNestedLessLess|DownLeftTeeVector|DownLeftVectorBar|RightAngleBracket|NotTildeFullEqual|NotReverseElement|RightUpDownVector|DiacriticalTilde|NotSucceedsTilde|circlearrowright|NotPrecedesEqual|rightharpoondown|DoubleRightArrow|NotSucceedsEqual|NonBreakingSpace|NotRightTriangle|LessEqualGreater|RightUpTeeVector|LeftAngleBracket|GreaterFullEqual|DownArrowUpArrow|RightUpVectorBar|twoheadleftarrow|GreaterEqualLess|downharpoonright|RightTriangleBar|ntrianglerighteq|NotSupersetEqual|LeftUpDownVector|DiacriticalAcute|rightrightarrows|vartriangleright|UpArrowDownArrow|DiacriticalGrave|UnderParenthesis|EmptySmallSquare|LeftUpVectorBar|leftrightarrows|DownRightVector|downharpoonleft|trianglerighteq|ShortRightArrow|OverParenthesis|DoubleLeftArrow|DoubleDownArrow|NotSquareSubset|bigtriangledown|ntrianglelefteq|UpperRightArrow|curvearrowright|vartriangleleft|NotLeftTriangle|nleftrightarrow|LowerRightArrow|NotHumpDownHump|NotGreaterTilde|rightthreetimes|LeftUpTeeVector|NotGreaterEqual|straightepsilon|LeftTriangleBar|rightsquigarrow|ContourIntegral|rightleftarrows|CloseCurlyQuote|RightDownVector|LeftRightVector|nLeftrightarrow|leftharpoondown|circlearrowleft|SquareSuperset|OpenCurlyQuote|hookrightarrow|HorizontalLine|DiacriticalDot|NotLessGreater|ntriangleright|DoubleRightTee|InvisibleComma|InvisibleTimes|LowerLeftArrow|DownLeftVector|NotSubsetEqual|curvearrowleft|trianglelefteq|NotVerticalBar|TildeFullEqual|downdownarrows|NotGreaterLess|RightTeeVector|ZeroWidthSpace|looparrowright|LongRightArrow|doublebarwedge|ShortLeftArrow|ShortDownArrow|RightVectorBar|GreaterGreater|ReverseElement|rightharpoonup|LessSlantEqual|leftthreetimes|upharpoonright|rightarrowtail|LeftDownVector|Longrightarrow|NestedLessLess|UpperLeftArrow|nshortparallel|leftleftarrows|leftrightarrow|Leftrightarrow|LeftRightArrow|longrightarrow|upharpoonleft|RightArrowBar|ApplyFunction|LeftTeeVector|leftarrowtail|NotEqualTilde|varsubsetneqq|varsupsetneqq|RightTeeArrow|SucceedsEqual|SucceedsTilde|LeftVectorBar|SupersetEqual|hookleftarrow|DifferentialD|VerticalTilde|VeryThinSpace|blacktriangle|bigtriangleup|LessFullEqual|divideontimes|leftharpoonup|UpEquilibrium|ntriangleleft|RightTriangle|measuredangle|shortparallel|longleftarrow|Longleftarrow|LongLeftArrow|DoubleLeftTee|Poincareplane|PrecedesEqual|triangleright|DoubleUpArrow|RightUpVector|fallingdotseq|looparrowleft|PrecedesTilde|NotTildeEqual|NotTildeTilde|smallsetminus|Proportional|triangleleft|triangledown|UnderBracket|NotHumpEqual|exponentiale|ExponentialE|NotLessTilde|HilbertSpace|RightCeiling|blacklozenge|varsupsetneq|HumpDownHump|GreaterEqual|VerticalLine|LeftTeeArrow|NotLessEqual|DownTeeArrow|LeftTriangle|varsubsetneq|Intersection|NotCongruent|DownArrowBar|LeftUpVector|LeftArrowBar|risingdotseq|GreaterTilde|RoundImplies|SquareSubset|ShortUpArrow|NotSuperset|quaternions|precnapprox|backepsilon|preccurlyeq|OverBracket|blacksquare|MediumSpace|VerticalBar|circledcirc|circleddash|CircleMinus|CircleTimes|LessGreater|curlyeqprec|curlyeqsucc|diamondsuit|UpDownArrow|Updownarrow|RuleDelayed|Rrightarrow|updownarrow|RightVector|nRightarrow|nrightarrow|eqslantless|LeftCeiling|Equilibrium|SmallCircle|expectation|NotSucceeds|thickapprox|GreaterLess|SquareUnion|NotPrecedes|NotLessLess|straightphi|succnapprox|succcurlyeq|SubsetEqual|sqsupseteq|Proportion|Laplacetrf|ImaginaryI|supsetneqq|NotGreater|gtreqqless|NotElement|ThickSpace|TildeEqual|TildeTilde|Fouriertrf|rmoustache|EqualTilde|eqslantgtr|UnderBrace|LeftVector|UpArrowBar|nLeftarrow|nsubseteqq|subsetneqq|nsupseteqq|nleftarrow|succapprox|lessapprox|UpTeeArrow|upuparrows|curlywedge|lesseqqgtr|varepsilon|varnothing|RightFloor|complement|CirclePlus|sqsubseteq|Lleftarrow|circledast|RightArrow|Rightarrow|rightarrow|lmoustache|Bernoullis|precapprox|mapstoleft|mapstodown|longmapsto|dotsquare|downarrow|DoubleDot|nsubseteq|supsetneq|leftarrow|nsupseteq|subsetneq|ThinSpace|ngeqslant|subseteqq|HumpEqual|NotSubset|triangleq|NotCupCap|lesseqgtr|heartsuit|TripleDot|Leftarrow|Coproduct|Congruent|varpropto|complexes|gvertneqq|LeftArrow|LessTilde|supseteqq|MinusPlus|CircleDot|nleqslant|NotExists|gtreqless|nparallel|UnionPlus|LeftFloor|checkmark|CenterDot|centerdot|Mellintrf|gtrapprox|bigotimes|OverBrace|spadesuit|therefore|pitchfork|rationals|PlusMinus|Backslash|Therefore|DownBreve|backsimeq|backprime|DownArrow|nshortmid|Downarrow|lvertneqq|eqvparsl|imagline|imagpart|infintie|integers|Integral|intercal|LessLess|Uarrocir|intlarhk|sqsupset|angmsdaf|sqsubset|llcorner|vartheta|cupbrcap|lnapprox|Superset|SuchThat|succnsim|succneqq|angmsdag|biguplus|curlyvee|trpezium|Succeeds|NotTilde|bigwedge|angmsdah|angrtvbd|triminus|cwconint|fpartint|lrcorner|smeparsl|subseteq|urcorner|lurdshar|laemptyv|DDotrahd|approxeq|ldrushar|awconint|mapstoup|backcong|shortmid|triangle|geqslant|gesdotol|timesbar|circledR|circledS|setminus|multimap|naturals|scpolint|ncongdot|RightTee|boxminus|gnapprox|boxtimes|andslope|thicksim|angmsdaa|varsigma|cirfnint|rtriltri|angmsdab|rppolint|angmsdac|barwedge|drbkarow|clubsuit|thetasym|bsolhsub|capbrcup|dzigrarr|doteqdot|DotEqual|dotminus|UnderBar|NotEqual|realpart|otimesas|ulcorner|hksearow|hkswarow|parallel|PartialD|elinters|emptyset|plusacir|bbrktbrk|angmsdad|pointint|bigoplus|angmsdae|Precedes|bigsqcup|varkappa|notindot|supseteq|precneqq|precnsim|profalar|profline|profsurf|leqslant|lesdotor|raemptyv|subplus|notnivb|notnivc|subrarr|zigrarr|vzigzag|submult|subedot|Element|between|cirscir|larrbfs|larrsim|lotimes|lbrksld|lbrkslu|lozenge|ldrdhar|dbkarow|bigcirc|epsilon|simrarr|simplus|ltquest|Epsilon|luruhar|gtquest|maltese|npolint|eqcolon|npreceq|bigodot|ddagger|gtrless|bnequiv|harrcir|ddotseq|equivDD|backsim|demptyv|nsqsube|nsqsupe|Upsilon|nsubset|upsilon|minusdu|nsucceq|swarrow|nsupset|coloneq|searrow|boxplus|napprox|natural|asympeq|alefsym|congdot|nearrow|bigstar|diamond|supplus|tritime|LeftTee|nvinfin|triplus|NewLine|nvltrie|nvrtrie|nwarrow|nexists|Diamond|ruluhar|Implies|supmult|angzarr|suplarr|suphsub|questeq|because|digamma|Because|olcross|bemptyv|omicron|Omicron|rotimes|NoBreak|intprod|angrtvb|orderof|uwangle|suphsol|lesdoto|orslope|DownTee|realine|cudarrl|rdldhar|OverBar|supedot|lessdot|supdsub|topfork|succsim|rbrkslu|rbrksld|pertenk|cudarrr|isindot|planckh|lessgtr|pluscir|gesdoto|plussim|plustwo|lesssim|cularrp|rarrsim|Cayleys|notinva|notinvb|notinvc|UpArrow|Uparrow|uparrow|NotLess|dwangle|precsim|Product|curarrm|Cconint|dotplus|rarrbfs|ccupssm|Cedilla|cemptyv|notniva|quatint|frac35|frac38|frac45|frac56|frac58|frac78|tridot|xoplus|gacute|gammad|Gammad|lfisht|lfloor|bigcup|sqsupe|gbreve|Gbreve|lharul|sqsube|sqcups|Gcedil|apacir|llhard|lmidot|Lmidot|lmoust|andand|sqcaps|approx|Abreve|spades|circeq|tprime|divide|topcir|Assign|topbot|gesdot|divonx|xuplus|timesd|gesles|atilde|solbar|SOFTcy|loplus|timesb|lowast|lowbar|dlcorn|dlcrop|softcy|dollar|lparlt|thksim|lrhard|Atilde|lsaquo|smashp|bigvee|thinsp|wreath|bkarow|lsquor|lstrok|Lstrok|lthree|ltimes|ltlarr|DotDot|simdot|ltrPar|weierp|xsqcup|angmsd|sigmav|sigmaf|zeetrf|Zcaron|zcaron|mapsto|vsupne|thetav|cirmid|marker|mcomma|Zacute|vsubnE|there4|gtlPar|vsubne|bottom|gtrarr|SHCHcy|shchcy|midast|midcir|middot|minusb|minusd|gtrdot|bowtie|sfrown|mnplus|models|colone|seswar|Colone|mstpos|searhk|gtrsim|nacute|Nacute|boxbox|telrec|hairsp|Tcedil|nbumpe|scnsim|ncaron|Ncaron|ncedil|Ncedil|hamilt|Scedil|nearhk|hardcy|HARDcy|tcedil|Tcaron|commat|nequiv|nesear|tcaron|target|hearts|nexist|varrho|scedil|Scaron|scaron|hellip|Sacute|sacute|hercon|swnwar|compfn|rtimes|rthree|rsquor|rsaquo|zacute|wedgeq|homtht|barvee|barwed|Barwed|rpargt|horbar|conint|swarhk|roplus|nltrie|hslash|hstrok|Hstrok|rmoust|Conint|bprime|hybull|hyphen|iacute|Iacute|supsup|supsub|supsim|varphi|coprod|brvbar|agrave|Supset|supset|igrave|Igrave|notinE|Agrave|iiiint|iinfin|copysr|wedbar|Verbar|vangrt|becaus|incare|verbar|inodot|bullet|drcorn|intcal|drcrop|cularr|vellip|Utilde|bumpeq|cupcap|dstrok|Dstrok|CupCap|cupcup|cupdot|eacute|Eacute|supdot|iquest|easter|ecaron|Ecaron|ecolon|isinsv|utilde|itilde|Itilde|curarr|succeq|Bumpeq|cacute|ulcrop|nparsl|Cacute|nprcue|egrave|Egrave|nrarrc|nrarrw|subsup|subsub|nrtrie|jsercy|nsccue|Jsercy|kappav|kcedil|Kcedil|subsim|ulcorn|nsimeq|egsdot|veebar|kgreen|capand|elsdot|Subset|subset|curren|aacute|lacute|Lacute|emptyv|ntilde|Ntilde|lagran|lambda|Lambda|capcap|Ugrave|langle|subdot|emsp13|numero|emsp14|nvdash|nvDash|nVdash|nVDash|ugrave|ufisht|nvHarr|larrfs|nvlArr|larrhk|larrlp|larrpl|nvrArr|Udblac|nwarhk|larrtl|nwnear|oacute|Oacute|latail|lAtail|sstarf|lbrace|odblac|Odblac|lbrack|udblac|odsold|eparsl|lcaron|Lcaron|ograve|Ograve|lcedil|Lcedil|Aacute|ssmile|ssetmn|squarf|ldquor|capcup|ominus|cylcty|rharul|eqcirc|dagger|rfloor|rfisht|Dagger|daleth|equals|origof|capdot|equest|dcaron|Dcaron|rdquor|oslash|Oslash|otilde|Otilde|otimes|Otimes|urcrop|Ubreve|ubreve|Yacute|Uacute|uacute|Rcedil|rcedil|urcorn|parsim|Rcaron|Vdashl|rcaron|Tstrok|percnt|period|permil|Exists|yacute|rbrack|rbrace|phmmat|ccaron|Ccaron|planck|ccedil|plankv|tstrok|female|plusdo|plusdu|ffilig|plusmn|ffllig|Ccedil|rAtail|dfisht|bernou|ratail|Rarrtl|rarrtl|angsph|rarrpl|rarrlp|rarrhk|xwedge|xotime|forall|ForAll|Vvdash|vsupnE|preceq|bigcap|frac12|frac13|frac14|primes|rarrfs|prnsim|frac15|Square|frac16|square|lesdot|frac18|frac23|propto|prurel|rarrap|rangle|puncsp|frac25|Racute|qprime|racute|lesges|frac34|abreve|AElig|eqsim|utdot|setmn|urtri|Equal|Uring|seArr|uring|searr|dashv|Dashv|mumap|nabla|iogon|Iogon|sdote|sdotb|scsim|napid|napos|equiv|natur|Acirc|dblac|erarr|nbump|iprod|erDot|ucirc|awint|esdot|angrt|ncong|isinE|scnap|Scirc|scirc|ndash|isins|Ubrcy|nearr|neArr|isinv|nedot|ubrcy|acute|Ycirc|iukcy|Iukcy|xutri|nesim|caret|jcirc|Jcirc|caron|twixt|ddarr|sccue|exist|jmath|sbquo|ngeqq|angst|ccaps|lceil|ngsim|UpTee|delta|Delta|rtrif|nharr|nhArr|nhpar|rtrie|jukcy|Jukcy|kappa|rsquo|Kappa|nlarr|nlArr|TSHcy|rrarr|aogon|Aogon|fflig|xrarr|tshcy|ccirc|nleqq|filig|upsih|nless|dharl|nlsim|fjlig|ropar|nltri|dharr|robrk|roarr|fllig|fltns|roang|rnmid|subnE|subne|lAarr|trisb|Ccirc|acirc|ccups|blank|VDash|forkv|Vdash|langd|cedil|blk12|blk14|laquo|strns|diams|notin|vDash|larrb|blk34|block|disin|uplus|vdash|vBarv|aelig|starf|Wedge|check|xrArr|lates|lbarr|lBarr|notni|lbbrk|bcong|frasl|lbrke|frown|vrtri|vprop|vnsup|gamma|Gamma|wedge|xodot|bdquo|srarr|doteq|ldquo|boxdl|boxdL|gcirc|Gcirc|boxDl|boxDL|boxdr|boxdR|boxDr|TRADE|trade|rlhar|boxDR|vnsub|npart|vltri|rlarr|boxhd|boxhD|nprec|gescc|nrarr|nrArr|boxHd|boxHD|boxhu|boxhU|nrtri|boxHu|clubs|boxHU|times|colon|Colon|gimel|xlArr|Tilde|nsime|tilde|nsmid|nspar|THORN|thorn|xlarr|nsube|nsubE|thkap|xhArr|comma|nsucc|boxul|boxuL|nsupe|nsupE|gneqq|gnsim|boxUl|boxUL|grave|boxur|boxuR|boxUr|boxUR|lescc|angle|bepsi|boxvh|varpi|boxvH|numsp|Theta|gsime|gsiml|theta|boxVh|boxVH|boxvl|gtcir|gtdot|boxvL|boxVl|boxVL|crarr|cross|Cross|nvsim|boxvr|nwarr|nwArr|sqsup|dtdot|Uogon|lhard|lharu|dtrif|ocirc|Ocirc|lhblk|duarr|odash|sqsub|Hacek|sqcup|llarr|duhar|oelig|OElig|ofcir|boxvR|uogon|lltri|boxVr|csube|uuarr|ohbar|csupe|ctdot|olarr|olcir|harrw|oline|sqcap|omacr|Omacr|omega|Omega|boxVR|aleph|lneqq|lnsim|loang|loarr|rharu|lobrk|hcirc|operp|oplus|rhard|Hcirc|orarr|Union|order|ecirc|Ecirc|cuepr|szlig|cuesc|breve|reals|eDDot|Breve|hoarr|lopar|utrif|rdquo|Umacr|umacr|efDot|swArr|ultri|alpha|rceil|ovbar|swarr|Wcirc|wcirc|smtes|smile|bsemi|lrarr|aring|parsl|lrhar|bsime|uhblk|lrtri|cupor|Aring|uharr|uharl|slarr|rbrke|bsolb|lsime|rbbrk|RBarr|lsimg|phone|rBarr|rbarr|icirc|lsquo|Icirc|emacr|Emacr|ratio|simne|plusb|simlE|simgE|simeq|pluse|ltcir|ltdot|empty|xharr|xdtri|iexcl|Alpha|ltrie|rarrw|pound|ltrif|xcirc|bumpe|prcue|bumpE|asymp|amacr|cuvee|Sigma|sigma|iiint|udhar|iiota|ijlig|IJlig|supnE|imacr|Imacr|prime|Prime|image|prnap|eogon|Eogon|rarrc|mdash|mDDot|cuwed|imath|supne|imped|Amacr|udarr|prsim|micro|rarrb|cwint|raquo|infin|eplus|range|rangd|Ucirc|radic|minus|amalg|veeeq|rAarr|epsiv|ycirc|quest|sharp|quot|zwnj|Qscr|race|qscr|Qopf|qopf|qint|rang|Rang|Zscr|zscr|Zopf|zopf|rarr|rArr|Rarr|Pscr|pscr|prop|prod|prnE|prec|ZHcy|zhcy|prap|Zeta|zeta|Popf|popf|Zdot|plus|zdot|Yuml|yuml|phiv|YUcy|yucy|Yscr|yscr|perp|Yopf|yopf|part|para|YIcy|Ouml|rcub|yicy|YAcy|rdca|ouml|osol|Oscr|rdsh|yacy|real|oscr|xvee|andd|rect|andv|Xscr|oror|ordm|ordf|xscr|ange|aopf|Aopf|rHar|Xopf|opar|Oopf|xopf|xnis|rhov|oopf|omid|xmap|oint|apid|apos|ogon|ascr|Ascr|odot|odiv|xcup|xcap|ocir|oast|nvlt|nvle|nvgt|nvge|nvap|Wscr|wscr|auml|ntlg|ntgl|nsup|nsub|nsim|Nscr|nscr|nsce|Wopf|ring|npre|wopf|npar|Auml|Barv|bbrk|Nopf|nopf|nmid|nLtv|beta|ropf|Ropf|Beta|beth|nles|rpar|nleq|bnot|bNot|nldr|NJcy|rscr|Rscr|Vscr|vscr|rsqb|njcy|bopf|nisd|Bopf|rtri|Vopf|nGtv|ngtr|vopf|boxh|boxH|boxv|nges|ngeq|boxV|bscr|scap|Bscr|bsim|Vert|vert|bsol|bull|bump|caps|cdot|ncup|scnE|ncap|nbsp|napE|Cdot|cent|sdot|Vbar|nang|vBar|chcy|Mscr|mscr|sect|semi|CHcy|Mopf|mopf|sext|circ|cire|mldr|mlcp|cirE|comp|shcy|SHcy|vArr|varr|cong|copf|Copf|copy|COPY|malt|male|macr|lvnE|cscr|ltri|sime|ltcc|simg|Cscr|siml|csub|Uuml|lsqb|lsim|uuml|csup|Lscr|lscr|utri|smid|lpar|cups|smte|lozf|darr|Lopf|Uscr|solb|lopf|sopf|Sopf|lneq|uscr|spar|dArr|lnap|Darr|dash|Sqrt|LJcy|ljcy|lHar|dHar|Upsi|upsi|diam|lesg|djcy|DJcy|leqq|dopf|Dopf|dscr|Dscr|dscy|ldsh|ldca|squf|DScy|sscr|Sscr|dsol|lcub|late|star|Star|Uopf|Larr|lArr|larr|uopf|dtri|dzcy|sube|subE|Lang|lang|Kscr|kscr|Kopf|kopf|KJcy|kjcy|KHcy|khcy|DZcy|ecir|edot|eDot|Jscr|jscr|succ|Jopf|jopf|Edot|uHar|emsp|ensp|Iuml|iuml|eopf|isin|Iscr|iscr|Eopf|epar|sung|epsi|escr|sup1|sup2|sup3|Iota|iota|supe|supE|Iopf|iopf|IOcy|iocy|Escr|esim|Esim|imof|Uarr|QUOT|uArr|uarr|euml|IEcy|iecy|Idot|Euml|euro|excl|Hscr|hscr|Hopf|hopf|TScy|tscy|Tscr|hbar|tscr|flat|tbrk|fnof|hArr|harr|half|fopf|Fopf|tdot|gvnE|fork|trie|gtcc|fscr|Fscr|gdot|gsim|Gscr|gscr|Gopf|gopf|gneq|Gdot|tosa|gnap|Topf|topf|geqq|toea|GJcy|gjcy|tint|gesl|mid|Sfr|ggg|top|ges|gla|glE|glj|geq|gne|gEl|gel|gnE|Gcy|gcy|gap|Tfr|tfr|Tcy|tcy|Hat|Tau|Ffr|tau|Tab|hfr|Hfr|ffr|Fcy|fcy|icy|Icy|iff|ETH|eth|ifr|Ifr|Eta|eta|int|Int|Sup|sup|ucy|Ucy|Sum|sum|jcy|ENG|ufr|Ufr|eng|Jcy|jfr|els|ell|egs|Efr|efr|Jfr|uml|kcy|Kcy|Ecy|ecy|kfr|Kfr|lap|Sub|sub|lat|lcy|Lcy|leg|Dot|dot|lEg|leq|les|squ|div|die|lfr|Lfr|lgE|Dfr|dfr|Del|deg|Dcy|dcy|lne|lnE|sol|loz|smt|Cup|lrm|cup|lsh|Lsh|sim|shy|map|Map|mcy|Mcy|mfr|Mfr|mho|gfr|Gfr|sfr|cir|Chi|chi|nap|Cfr|vcy|Vcy|cfr|Scy|scy|ncy|Ncy|vee|Vee|Cap|cap|nfr|scE|sce|Nfr|nge|ngE|nGg|vfr|Vfr|ngt|bot|nGt|nis|niv|Rsh|rsh|nle|nlE|bne|Bfr|bfr|nLl|nlt|nLt|Bcy|bcy|not|Not|rlm|wfr|Wfr|npr|nsc|num|ocy|ast|Ocy|ofr|xfr|Xfr|Ofr|ogt|ohm|apE|olt|Rho|ape|rho|Rfr|rfr|ord|REG|ang|reg|orv|And|and|AMP|Rcy|amp|Afr|ycy|Ycy|yen|yfr|Yfr|rcy|par|pcy|Pcy|pfr|Pfr|phi|Phi|afr|Acy|acy|zcy|Zcy|piv|acE|acd|zfr|Zfr|pre|prE|psi|Psi|qfr|Qfr|zwj|Or|ge|Gg|gt|gg|el|oS|lt|Lt|LT|Re|lg|gl|eg|ne|Im|it|le|DD|wp|wr|nu|Nu|dd|lE|Sc|sc|pi|Pi|ee|af|ll|Ll|rx|gE|xi|pm|Xi|ic|pr|Pr|in|ni|mp|mu|ac|Mu|or|ap|Gt|GT|ii);|&(Aacute|Agrave|Atilde|Ccedil|Eacute|Egrave|Iacute|Igrave|Ntilde|Oacute|Ograve|Oslash|Otilde|Uacute|Ugrave|Yacute|aacute|agrave|atilde|brvbar|ccedil|curren|divide|eacute|egrave|frac12|frac14|frac34|iacute|igrave|iquest|middot|ntilde|oacute|ograve|oslash|otilde|plusmn|uacute|ugrave|yacute|AElig|Acirc|Aring|Ecirc|Icirc|Ocirc|THORN|Ucirc|acirc|acute|aelig|aring|cedil|ecirc|icirc|iexcl|laquo|micro|ocirc|pound|raquo|szlig|thorn|times|ucirc|Auml|COPY|Euml|Iuml|Ouml|QUOT|Uuml|auml|cent|copy|euml|iuml|macr|nbsp|ordf|ordm|ouml|para|quot|sect|sup1|sup2|sup3|uuml|yuml|AMP|ETH|REG|amp|deg|eth|not|reg|shy|uml|yen|GT|LT|gt|lt)(?!;)([=a-zA-Z0-9]?)|&#([0-9]+)(;?)|&#[xX]([a-fA-F0-9]+)(;?)|&([0-9a-zA-Z]+)/g;
  	var decodeMap = {'aacute':'\xE1','Aacute':'\xC1','abreve':'\u0103','Abreve':'\u0102','ac':'\u223E','acd':'\u223F','acE':'\u223E\u0333','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','acy':'\u0430','Acy':'\u0410','aelig':'\xE6','AElig':'\xC6','af':'\u2061','afr':'\uD835\uDD1E','Afr':'\uD835\uDD04','agrave':'\xE0','Agrave':'\xC0','alefsym':'\u2135','aleph':'\u2135','alpha':'\u03B1','Alpha':'\u0391','amacr':'\u0101','Amacr':'\u0100','amalg':'\u2A3F','amp':'&','AMP':'&','and':'\u2227','And':'\u2A53','andand':'\u2A55','andd':'\u2A5C','andslope':'\u2A58','andv':'\u2A5A','ang':'\u2220','ange':'\u29A4','angle':'\u2220','angmsd':'\u2221','angmsdaa':'\u29A8','angmsdab':'\u29A9','angmsdac':'\u29AA','angmsdad':'\u29AB','angmsdae':'\u29AC','angmsdaf':'\u29AD','angmsdag':'\u29AE','angmsdah':'\u29AF','angrt':'\u221F','angrtvb':'\u22BE','angrtvbd':'\u299D','angsph':'\u2222','angst':'\xC5','angzarr':'\u237C','aogon':'\u0105','Aogon':'\u0104','aopf':'\uD835\uDD52','Aopf':'\uD835\uDD38','ap':'\u2248','apacir':'\u2A6F','ape':'\u224A','apE':'\u2A70','apid':'\u224B','apos':'\'','ApplyFunction':'\u2061','approx':'\u2248','approxeq':'\u224A','aring':'\xE5','Aring':'\xC5','ascr':'\uD835\uDCB6','Ascr':'\uD835\uDC9C','Assign':'\u2254','ast':'*','asymp':'\u2248','asympeq':'\u224D','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','awconint':'\u2233','awint':'\u2A11','backcong':'\u224C','backepsilon':'\u03F6','backprime':'\u2035','backsim':'\u223D','backsimeq':'\u22CD','Backslash':'\u2216','Barv':'\u2AE7','barvee':'\u22BD','barwed':'\u2305','Barwed':'\u2306','barwedge':'\u2305','bbrk':'\u23B5','bbrktbrk':'\u23B6','bcong':'\u224C','bcy':'\u0431','Bcy':'\u0411','bdquo':'\u201E','becaus':'\u2235','because':'\u2235','Because':'\u2235','bemptyv':'\u29B0','bepsi':'\u03F6','bernou':'\u212C','Bernoullis':'\u212C','beta':'\u03B2','Beta':'\u0392','beth':'\u2136','between':'\u226C','bfr':'\uD835\uDD1F','Bfr':'\uD835\uDD05','bigcap':'\u22C2','bigcirc':'\u25EF','bigcup':'\u22C3','bigodot':'\u2A00','bigoplus':'\u2A01','bigotimes':'\u2A02','bigsqcup':'\u2A06','bigstar':'\u2605','bigtriangledown':'\u25BD','bigtriangleup':'\u25B3','biguplus':'\u2A04','bigvee':'\u22C1','bigwedge':'\u22C0','bkarow':'\u290D','blacklozenge':'\u29EB','blacksquare':'\u25AA','blacktriangle':'\u25B4','blacktriangledown':'\u25BE','blacktriangleleft':'\u25C2','blacktriangleright':'\u25B8','blank':'\u2423','blk12':'\u2592','blk14':'\u2591','blk34':'\u2593','block':'\u2588','bne':'=\u20E5','bnequiv':'\u2261\u20E5','bnot':'\u2310','bNot':'\u2AED','bopf':'\uD835\uDD53','Bopf':'\uD835\uDD39','bot':'\u22A5','bottom':'\u22A5','bowtie':'\u22C8','boxbox':'\u29C9','boxdl':'\u2510','boxdL':'\u2555','boxDl':'\u2556','boxDL':'\u2557','boxdr':'\u250C','boxdR':'\u2552','boxDr':'\u2553','boxDR':'\u2554','boxh':'\u2500','boxH':'\u2550','boxhd':'\u252C','boxhD':'\u2565','boxHd':'\u2564','boxHD':'\u2566','boxhu':'\u2534','boxhU':'\u2568','boxHu':'\u2567','boxHU':'\u2569','boxminus':'\u229F','boxplus':'\u229E','boxtimes':'\u22A0','boxul':'\u2518','boxuL':'\u255B','boxUl':'\u255C','boxUL':'\u255D','boxur':'\u2514','boxuR':'\u2558','boxUr':'\u2559','boxUR':'\u255A','boxv':'\u2502','boxV':'\u2551','boxvh':'\u253C','boxvH':'\u256A','boxVh':'\u256B','boxVH':'\u256C','boxvl':'\u2524','boxvL':'\u2561','boxVl':'\u2562','boxVL':'\u2563','boxvr':'\u251C','boxvR':'\u255E','boxVr':'\u255F','boxVR':'\u2560','bprime':'\u2035','breve':'\u02D8','Breve':'\u02D8','brvbar':'\xA6','bscr':'\uD835\uDCB7','Bscr':'\u212C','bsemi':'\u204F','bsim':'\u223D','bsime':'\u22CD','bsol':'\\','bsolb':'\u29C5','bsolhsub':'\u27C8','bull':'\u2022','bullet':'\u2022','bump':'\u224E','bumpe':'\u224F','bumpE':'\u2AAE','bumpeq':'\u224F','Bumpeq':'\u224E','cacute':'\u0107','Cacute':'\u0106','cap':'\u2229','Cap':'\u22D2','capand':'\u2A44','capbrcup':'\u2A49','capcap':'\u2A4B','capcup':'\u2A47','capdot':'\u2A40','CapitalDifferentialD':'\u2145','caps':'\u2229\uFE00','caret':'\u2041','caron':'\u02C7','Cayleys':'\u212D','ccaps':'\u2A4D','ccaron':'\u010D','Ccaron':'\u010C','ccedil':'\xE7','Ccedil':'\xC7','ccirc':'\u0109','Ccirc':'\u0108','Cconint':'\u2230','ccups':'\u2A4C','ccupssm':'\u2A50','cdot':'\u010B','Cdot':'\u010A','cedil':'\xB8','Cedilla':'\xB8','cemptyv':'\u29B2','cent':'\xA2','centerdot':'\xB7','CenterDot':'\xB7','cfr':'\uD835\uDD20','Cfr':'\u212D','chcy':'\u0447','CHcy':'\u0427','check':'\u2713','checkmark':'\u2713','chi':'\u03C7','Chi':'\u03A7','cir':'\u25CB','circ':'\u02C6','circeq':'\u2257','circlearrowleft':'\u21BA','circlearrowright':'\u21BB','circledast':'\u229B','circledcirc':'\u229A','circleddash':'\u229D','CircleDot':'\u2299','circledR':'\xAE','circledS':'\u24C8','CircleMinus':'\u2296','CirclePlus':'\u2295','CircleTimes':'\u2297','cire':'\u2257','cirE':'\u29C3','cirfnint':'\u2A10','cirmid':'\u2AEF','cirscir':'\u29C2','ClockwiseContourIntegral':'\u2232','CloseCurlyDoubleQuote':'\u201D','CloseCurlyQuote':'\u2019','clubs':'\u2663','clubsuit':'\u2663','colon':':','Colon':'\u2237','colone':'\u2254','Colone':'\u2A74','coloneq':'\u2254','comma':',','commat':'@','comp':'\u2201','compfn':'\u2218','complement':'\u2201','complexes':'\u2102','cong':'\u2245','congdot':'\u2A6D','Congruent':'\u2261','conint':'\u222E','Conint':'\u222F','ContourIntegral':'\u222E','copf':'\uD835\uDD54','Copf':'\u2102','coprod':'\u2210','Coproduct':'\u2210','copy':'\xA9','COPY':'\xA9','copysr':'\u2117','CounterClockwiseContourIntegral':'\u2233','crarr':'\u21B5','cross':'\u2717','Cross':'\u2A2F','cscr':'\uD835\uDCB8','Cscr':'\uD835\uDC9E','csub':'\u2ACF','csube':'\u2AD1','csup':'\u2AD0','csupe':'\u2AD2','ctdot':'\u22EF','cudarrl':'\u2938','cudarrr':'\u2935','cuepr':'\u22DE','cuesc':'\u22DF','cularr':'\u21B6','cularrp':'\u293D','cup':'\u222A','Cup':'\u22D3','cupbrcap':'\u2A48','cupcap':'\u2A46','CupCap':'\u224D','cupcup':'\u2A4A','cupdot':'\u228D','cupor':'\u2A45','cups':'\u222A\uFE00','curarr':'\u21B7','curarrm':'\u293C','curlyeqprec':'\u22DE','curlyeqsucc':'\u22DF','curlyvee':'\u22CE','curlywedge':'\u22CF','curren':'\xA4','curvearrowleft':'\u21B6','curvearrowright':'\u21B7','cuvee':'\u22CE','cuwed':'\u22CF','cwconint':'\u2232','cwint':'\u2231','cylcty':'\u232D','dagger':'\u2020','Dagger':'\u2021','daleth':'\u2138','darr':'\u2193','dArr':'\u21D3','Darr':'\u21A1','dash':'\u2010','dashv':'\u22A3','Dashv':'\u2AE4','dbkarow':'\u290F','dblac':'\u02DD','dcaron':'\u010F','Dcaron':'\u010E','dcy':'\u0434','Dcy':'\u0414','dd':'\u2146','DD':'\u2145','ddagger':'\u2021','ddarr':'\u21CA','DDotrahd':'\u2911','ddotseq':'\u2A77','deg':'\xB0','Del':'\u2207','delta':'\u03B4','Delta':'\u0394','demptyv':'\u29B1','dfisht':'\u297F','dfr':'\uD835\uDD21','Dfr':'\uD835\uDD07','dHar':'\u2965','dharl':'\u21C3','dharr':'\u21C2','DiacriticalAcute':'\xB4','DiacriticalDot':'\u02D9','DiacriticalDoubleAcute':'\u02DD','DiacriticalGrave':'`','DiacriticalTilde':'\u02DC','diam':'\u22C4','diamond':'\u22C4','Diamond':'\u22C4','diamondsuit':'\u2666','diams':'\u2666','die':'\xA8','DifferentialD':'\u2146','digamma':'\u03DD','disin':'\u22F2','div':'\xF7','divide':'\xF7','divideontimes':'\u22C7','divonx':'\u22C7','djcy':'\u0452','DJcy':'\u0402','dlcorn':'\u231E','dlcrop':'\u230D','dollar':'$','dopf':'\uD835\uDD55','Dopf':'\uD835\uDD3B','dot':'\u02D9','Dot':'\xA8','DotDot':'\u20DC','doteq':'\u2250','doteqdot':'\u2251','DotEqual':'\u2250','dotminus':'\u2238','dotplus':'\u2214','dotsquare':'\u22A1','doublebarwedge':'\u2306','DoubleContourIntegral':'\u222F','DoubleDot':'\xA8','DoubleDownArrow':'\u21D3','DoubleLeftArrow':'\u21D0','DoubleLeftRightArrow':'\u21D4','DoubleLeftTee':'\u2AE4','DoubleLongLeftArrow':'\u27F8','DoubleLongLeftRightArrow':'\u27FA','DoubleLongRightArrow':'\u27F9','DoubleRightArrow':'\u21D2','DoubleRightTee':'\u22A8','DoubleUpArrow':'\u21D1','DoubleUpDownArrow':'\u21D5','DoubleVerticalBar':'\u2225','downarrow':'\u2193','Downarrow':'\u21D3','DownArrow':'\u2193','DownArrowBar':'\u2913','DownArrowUpArrow':'\u21F5','DownBreve':'\u0311','downdownarrows':'\u21CA','downharpoonleft':'\u21C3','downharpoonright':'\u21C2','DownLeftRightVector':'\u2950','DownLeftTeeVector':'\u295E','DownLeftVector':'\u21BD','DownLeftVectorBar':'\u2956','DownRightTeeVector':'\u295F','DownRightVector':'\u21C1','DownRightVectorBar':'\u2957','DownTee':'\u22A4','DownTeeArrow':'\u21A7','drbkarow':'\u2910','drcorn':'\u231F','drcrop':'\u230C','dscr':'\uD835\uDCB9','Dscr':'\uD835\uDC9F','dscy':'\u0455','DScy':'\u0405','dsol':'\u29F6','dstrok':'\u0111','Dstrok':'\u0110','dtdot':'\u22F1','dtri':'\u25BF','dtrif':'\u25BE','duarr':'\u21F5','duhar':'\u296F','dwangle':'\u29A6','dzcy':'\u045F','DZcy':'\u040F','dzigrarr':'\u27FF','eacute':'\xE9','Eacute':'\xC9','easter':'\u2A6E','ecaron':'\u011B','Ecaron':'\u011A','ecir':'\u2256','ecirc':'\xEA','Ecirc':'\xCA','ecolon':'\u2255','ecy':'\u044D','Ecy':'\u042D','eDDot':'\u2A77','edot':'\u0117','eDot':'\u2251','Edot':'\u0116','ee':'\u2147','efDot':'\u2252','efr':'\uD835\uDD22','Efr':'\uD835\uDD08','eg':'\u2A9A','egrave':'\xE8','Egrave':'\xC8','egs':'\u2A96','egsdot':'\u2A98','el':'\u2A99','Element':'\u2208','elinters':'\u23E7','ell':'\u2113','els':'\u2A95','elsdot':'\u2A97','emacr':'\u0113','Emacr':'\u0112','empty':'\u2205','emptyset':'\u2205','EmptySmallSquare':'\u25FB','emptyv':'\u2205','EmptyVerySmallSquare':'\u25AB','emsp':'\u2003','emsp13':'\u2004','emsp14':'\u2005','eng':'\u014B','ENG':'\u014A','ensp':'\u2002','eogon':'\u0119','Eogon':'\u0118','eopf':'\uD835\uDD56','Eopf':'\uD835\uDD3C','epar':'\u22D5','eparsl':'\u29E3','eplus':'\u2A71','epsi':'\u03B5','epsilon':'\u03B5','Epsilon':'\u0395','epsiv':'\u03F5','eqcirc':'\u2256','eqcolon':'\u2255','eqsim':'\u2242','eqslantgtr':'\u2A96','eqslantless':'\u2A95','Equal':'\u2A75','equals':'=','EqualTilde':'\u2242','equest':'\u225F','Equilibrium':'\u21CC','equiv':'\u2261','equivDD':'\u2A78','eqvparsl':'\u29E5','erarr':'\u2971','erDot':'\u2253','escr':'\u212F','Escr':'\u2130','esdot':'\u2250','esim':'\u2242','Esim':'\u2A73','eta':'\u03B7','Eta':'\u0397','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','euro':'\u20AC','excl':'!','exist':'\u2203','Exists':'\u2203','expectation':'\u2130','exponentiale':'\u2147','ExponentialE':'\u2147','fallingdotseq':'\u2252','fcy':'\u0444','Fcy':'\u0424','female':'\u2640','ffilig':'\uFB03','fflig':'\uFB00','ffllig':'\uFB04','ffr':'\uD835\uDD23','Ffr':'\uD835\uDD09','filig':'\uFB01','FilledSmallSquare':'\u25FC','FilledVerySmallSquare':'\u25AA','fjlig':'fj','flat':'\u266D','fllig':'\uFB02','fltns':'\u25B1','fnof':'\u0192','fopf':'\uD835\uDD57','Fopf':'\uD835\uDD3D','forall':'\u2200','ForAll':'\u2200','fork':'\u22D4','forkv':'\u2AD9','Fouriertrf':'\u2131','fpartint':'\u2A0D','frac12':'\xBD','frac13':'\u2153','frac14':'\xBC','frac15':'\u2155','frac16':'\u2159','frac18':'\u215B','frac23':'\u2154','frac25':'\u2156','frac34':'\xBE','frac35':'\u2157','frac38':'\u215C','frac45':'\u2158','frac56':'\u215A','frac58':'\u215D','frac78':'\u215E','frasl':'\u2044','frown':'\u2322','fscr':'\uD835\uDCBB','Fscr':'\u2131','gacute':'\u01F5','gamma':'\u03B3','Gamma':'\u0393','gammad':'\u03DD','Gammad':'\u03DC','gap':'\u2A86','gbreve':'\u011F','Gbreve':'\u011E','Gcedil':'\u0122','gcirc':'\u011D','Gcirc':'\u011C','gcy':'\u0433','Gcy':'\u0413','gdot':'\u0121','Gdot':'\u0120','ge':'\u2265','gE':'\u2267','gel':'\u22DB','gEl':'\u2A8C','geq':'\u2265','geqq':'\u2267','geqslant':'\u2A7E','ges':'\u2A7E','gescc':'\u2AA9','gesdot':'\u2A80','gesdoto':'\u2A82','gesdotol':'\u2A84','gesl':'\u22DB\uFE00','gesles':'\u2A94','gfr':'\uD835\uDD24','Gfr':'\uD835\uDD0A','gg':'\u226B','Gg':'\u22D9','ggg':'\u22D9','gimel':'\u2137','gjcy':'\u0453','GJcy':'\u0403','gl':'\u2277','gla':'\u2AA5','glE':'\u2A92','glj':'\u2AA4','gnap':'\u2A8A','gnapprox':'\u2A8A','gne':'\u2A88','gnE':'\u2269','gneq':'\u2A88','gneqq':'\u2269','gnsim':'\u22E7','gopf':'\uD835\uDD58','Gopf':'\uD835\uDD3E','grave':'`','GreaterEqual':'\u2265','GreaterEqualLess':'\u22DB','GreaterFullEqual':'\u2267','GreaterGreater':'\u2AA2','GreaterLess':'\u2277','GreaterSlantEqual':'\u2A7E','GreaterTilde':'\u2273','gscr':'\u210A','Gscr':'\uD835\uDCA2','gsim':'\u2273','gsime':'\u2A8E','gsiml':'\u2A90','gt':'>','Gt':'\u226B','GT':'>','gtcc':'\u2AA7','gtcir':'\u2A7A','gtdot':'\u22D7','gtlPar':'\u2995','gtquest':'\u2A7C','gtrapprox':'\u2A86','gtrarr':'\u2978','gtrdot':'\u22D7','gtreqless':'\u22DB','gtreqqless':'\u2A8C','gtrless':'\u2277','gtrsim':'\u2273','gvertneqq':'\u2269\uFE00','gvnE':'\u2269\uFE00','Hacek':'\u02C7','hairsp':'\u200A','half':'\xBD','hamilt':'\u210B','hardcy':'\u044A','HARDcy':'\u042A','harr':'\u2194','hArr':'\u21D4','harrcir':'\u2948','harrw':'\u21AD','Hat':'^','hbar':'\u210F','hcirc':'\u0125','Hcirc':'\u0124','hearts':'\u2665','heartsuit':'\u2665','hellip':'\u2026','hercon':'\u22B9','hfr':'\uD835\uDD25','Hfr':'\u210C','HilbertSpace':'\u210B','hksearow':'\u2925','hkswarow':'\u2926','hoarr':'\u21FF','homtht':'\u223B','hookleftarrow':'\u21A9','hookrightarrow':'\u21AA','hopf':'\uD835\uDD59','Hopf':'\u210D','horbar':'\u2015','HorizontalLine':'\u2500','hscr':'\uD835\uDCBD','Hscr':'\u210B','hslash':'\u210F','hstrok':'\u0127','Hstrok':'\u0126','HumpDownHump':'\u224E','HumpEqual':'\u224F','hybull':'\u2043','hyphen':'\u2010','iacute':'\xED','Iacute':'\xCD','ic':'\u2063','icirc':'\xEE','Icirc':'\xCE','icy':'\u0438','Icy':'\u0418','Idot':'\u0130','iecy':'\u0435','IEcy':'\u0415','iexcl':'\xA1','iff':'\u21D4','ifr':'\uD835\uDD26','Ifr':'\u2111','igrave':'\xEC','Igrave':'\xCC','ii':'\u2148','iiiint':'\u2A0C','iiint':'\u222D','iinfin':'\u29DC','iiota':'\u2129','ijlig':'\u0133','IJlig':'\u0132','Im':'\u2111','imacr':'\u012B','Imacr':'\u012A','image':'\u2111','ImaginaryI':'\u2148','imagline':'\u2110','imagpart':'\u2111','imath':'\u0131','imof':'\u22B7','imped':'\u01B5','Implies':'\u21D2','in':'\u2208','incare':'\u2105','infin':'\u221E','infintie':'\u29DD','inodot':'\u0131','int':'\u222B','Int':'\u222C','intcal':'\u22BA','integers':'\u2124','Integral':'\u222B','intercal':'\u22BA','Intersection':'\u22C2','intlarhk':'\u2A17','intprod':'\u2A3C','InvisibleComma':'\u2063','InvisibleTimes':'\u2062','iocy':'\u0451','IOcy':'\u0401','iogon':'\u012F','Iogon':'\u012E','iopf':'\uD835\uDD5A','Iopf':'\uD835\uDD40','iota':'\u03B9','Iota':'\u0399','iprod':'\u2A3C','iquest':'\xBF','iscr':'\uD835\uDCBE','Iscr':'\u2110','isin':'\u2208','isindot':'\u22F5','isinE':'\u22F9','isins':'\u22F4','isinsv':'\u22F3','isinv':'\u2208','it':'\u2062','itilde':'\u0129','Itilde':'\u0128','iukcy':'\u0456','Iukcy':'\u0406','iuml':'\xEF','Iuml':'\xCF','jcirc':'\u0135','Jcirc':'\u0134','jcy':'\u0439','Jcy':'\u0419','jfr':'\uD835\uDD27','Jfr':'\uD835\uDD0D','jmath':'\u0237','jopf':'\uD835\uDD5B','Jopf':'\uD835\uDD41','jscr':'\uD835\uDCBF','Jscr':'\uD835\uDCA5','jsercy':'\u0458','Jsercy':'\u0408','jukcy':'\u0454','Jukcy':'\u0404','kappa':'\u03BA','Kappa':'\u039A','kappav':'\u03F0','kcedil':'\u0137','Kcedil':'\u0136','kcy':'\u043A','Kcy':'\u041A','kfr':'\uD835\uDD28','Kfr':'\uD835\uDD0E','kgreen':'\u0138','khcy':'\u0445','KHcy':'\u0425','kjcy':'\u045C','KJcy':'\u040C','kopf':'\uD835\uDD5C','Kopf':'\uD835\uDD42','kscr':'\uD835\uDCC0','Kscr':'\uD835\uDCA6','lAarr':'\u21DA','lacute':'\u013A','Lacute':'\u0139','laemptyv':'\u29B4','lagran':'\u2112','lambda':'\u03BB','Lambda':'\u039B','lang':'\u27E8','Lang':'\u27EA','langd':'\u2991','langle':'\u27E8','lap':'\u2A85','Laplacetrf':'\u2112','laquo':'\xAB','larr':'\u2190','lArr':'\u21D0','Larr':'\u219E','larrb':'\u21E4','larrbfs':'\u291F','larrfs':'\u291D','larrhk':'\u21A9','larrlp':'\u21AB','larrpl':'\u2939','larrsim':'\u2973','larrtl':'\u21A2','lat':'\u2AAB','latail':'\u2919','lAtail':'\u291B','late':'\u2AAD','lates':'\u2AAD\uFE00','lbarr':'\u290C','lBarr':'\u290E','lbbrk':'\u2772','lbrace':'{','lbrack':'[','lbrke':'\u298B','lbrksld':'\u298F','lbrkslu':'\u298D','lcaron':'\u013E','Lcaron':'\u013D','lcedil':'\u013C','Lcedil':'\u013B','lceil':'\u2308','lcub':'{','lcy':'\u043B','Lcy':'\u041B','ldca':'\u2936','ldquo':'\u201C','ldquor':'\u201E','ldrdhar':'\u2967','ldrushar':'\u294B','ldsh':'\u21B2','le':'\u2264','lE':'\u2266','LeftAngleBracket':'\u27E8','leftarrow':'\u2190','Leftarrow':'\u21D0','LeftArrow':'\u2190','LeftArrowBar':'\u21E4','LeftArrowRightArrow':'\u21C6','leftarrowtail':'\u21A2','LeftCeiling':'\u2308','LeftDoubleBracket':'\u27E6','LeftDownTeeVector':'\u2961','LeftDownVector':'\u21C3','LeftDownVectorBar':'\u2959','LeftFloor':'\u230A','leftharpoondown':'\u21BD','leftharpoonup':'\u21BC','leftleftarrows':'\u21C7','leftrightarrow':'\u2194','Leftrightarrow':'\u21D4','LeftRightArrow':'\u2194','leftrightarrows':'\u21C6','leftrightharpoons':'\u21CB','leftrightsquigarrow':'\u21AD','LeftRightVector':'\u294E','LeftTee':'\u22A3','LeftTeeArrow':'\u21A4','LeftTeeVector':'\u295A','leftthreetimes':'\u22CB','LeftTriangle':'\u22B2','LeftTriangleBar':'\u29CF','LeftTriangleEqual':'\u22B4','LeftUpDownVector':'\u2951','LeftUpTeeVector':'\u2960','LeftUpVector':'\u21BF','LeftUpVectorBar':'\u2958','LeftVector':'\u21BC','LeftVectorBar':'\u2952','leg':'\u22DA','lEg':'\u2A8B','leq':'\u2264','leqq':'\u2266','leqslant':'\u2A7D','les':'\u2A7D','lescc':'\u2AA8','lesdot':'\u2A7F','lesdoto':'\u2A81','lesdotor':'\u2A83','lesg':'\u22DA\uFE00','lesges':'\u2A93','lessapprox':'\u2A85','lessdot':'\u22D6','lesseqgtr':'\u22DA','lesseqqgtr':'\u2A8B','LessEqualGreater':'\u22DA','LessFullEqual':'\u2266','LessGreater':'\u2276','lessgtr':'\u2276','LessLess':'\u2AA1','lesssim':'\u2272','LessSlantEqual':'\u2A7D','LessTilde':'\u2272','lfisht':'\u297C','lfloor':'\u230A','lfr':'\uD835\uDD29','Lfr':'\uD835\uDD0F','lg':'\u2276','lgE':'\u2A91','lHar':'\u2962','lhard':'\u21BD','lharu':'\u21BC','lharul':'\u296A','lhblk':'\u2584','ljcy':'\u0459','LJcy':'\u0409','ll':'\u226A','Ll':'\u22D8','llarr':'\u21C7','llcorner':'\u231E','Lleftarrow':'\u21DA','llhard':'\u296B','lltri':'\u25FA','lmidot':'\u0140','Lmidot':'\u013F','lmoust':'\u23B0','lmoustache':'\u23B0','lnap':'\u2A89','lnapprox':'\u2A89','lne':'\u2A87','lnE':'\u2268','lneq':'\u2A87','lneqq':'\u2268','lnsim':'\u22E6','loang':'\u27EC','loarr':'\u21FD','lobrk':'\u27E6','longleftarrow':'\u27F5','Longleftarrow':'\u27F8','LongLeftArrow':'\u27F5','longleftrightarrow':'\u27F7','Longleftrightarrow':'\u27FA','LongLeftRightArrow':'\u27F7','longmapsto':'\u27FC','longrightarrow':'\u27F6','Longrightarrow':'\u27F9','LongRightArrow':'\u27F6','looparrowleft':'\u21AB','looparrowright':'\u21AC','lopar':'\u2985','lopf':'\uD835\uDD5D','Lopf':'\uD835\uDD43','loplus':'\u2A2D','lotimes':'\u2A34','lowast':'\u2217','lowbar':'_','LowerLeftArrow':'\u2199','LowerRightArrow':'\u2198','loz':'\u25CA','lozenge':'\u25CA','lozf':'\u29EB','lpar':'(','lparlt':'\u2993','lrarr':'\u21C6','lrcorner':'\u231F','lrhar':'\u21CB','lrhard':'\u296D','lrm':'\u200E','lrtri':'\u22BF','lsaquo':'\u2039','lscr':'\uD835\uDCC1','Lscr':'\u2112','lsh':'\u21B0','Lsh':'\u21B0','lsim':'\u2272','lsime':'\u2A8D','lsimg':'\u2A8F','lsqb':'[','lsquo':'\u2018','lsquor':'\u201A','lstrok':'\u0142','Lstrok':'\u0141','lt':'<','Lt':'\u226A','LT':'<','ltcc':'\u2AA6','ltcir':'\u2A79','ltdot':'\u22D6','lthree':'\u22CB','ltimes':'\u22C9','ltlarr':'\u2976','ltquest':'\u2A7B','ltri':'\u25C3','ltrie':'\u22B4','ltrif':'\u25C2','ltrPar':'\u2996','lurdshar':'\u294A','luruhar':'\u2966','lvertneqq':'\u2268\uFE00','lvnE':'\u2268\uFE00','macr':'\xAF','male':'\u2642','malt':'\u2720','maltese':'\u2720','map':'\u21A6','Map':'\u2905','mapsto':'\u21A6','mapstodown':'\u21A7','mapstoleft':'\u21A4','mapstoup':'\u21A5','marker':'\u25AE','mcomma':'\u2A29','mcy':'\u043C','Mcy':'\u041C','mdash':'\u2014','mDDot':'\u223A','measuredangle':'\u2221','MediumSpace':'\u205F','Mellintrf':'\u2133','mfr':'\uD835\uDD2A','Mfr':'\uD835\uDD10','mho':'\u2127','micro':'\xB5','mid':'\u2223','midast':'*','midcir':'\u2AF0','middot':'\xB7','minus':'\u2212','minusb':'\u229F','minusd':'\u2238','minusdu':'\u2A2A','MinusPlus':'\u2213','mlcp':'\u2ADB','mldr':'\u2026','mnplus':'\u2213','models':'\u22A7','mopf':'\uD835\uDD5E','Mopf':'\uD835\uDD44','mp':'\u2213','mscr':'\uD835\uDCC2','Mscr':'\u2133','mstpos':'\u223E','mu':'\u03BC','Mu':'\u039C','multimap':'\u22B8','mumap':'\u22B8','nabla':'\u2207','nacute':'\u0144','Nacute':'\u0143','nang':'\u2220\u20D2','nap':'\u2249','napE':'\u2A70\u0338','napid':'\u224B\u0338','napos':'\u0149','napprox':'\u2249','natur':'\u266E','natural':'\u266E','naturals':'\u2115','nbsp':'\xA0','nbump':'\u224E\u0338','nbumpe':'\u224F\u0338','ncap':'\u2A43','ncaron':'\u0148','Ncaron':'\u0147','ncedil':'\u0146','Ncedil':'\u0145','ncong':'\u2247','ncongdot':'\u2A6D\u0338','ncup':'\u2A42','ncy':'\u043D','Ncy':'\u041D','ndash':'\u2013','ne':'\u2260','nearhk':'\u2924','nearr':'\u2197','neArr':'\u21D7','nearrow':'\u2197','nedot':'\u2250\u0338','NegativeMediumSpace':'\u200B','NegativeThickSpace':'\u200B','NegativeThinSpace':'\u200B','NegativeVeryThinSpace':'\u200B','nequiv':'\u2262','nesear':'\u2928','nesim':'\u2242\u0338','NestedGreaterGreater':'\u226B','NestedLessLess':'\u226A','NewLine':'\n','nexist':'\u2204','nexists':'\u2204','nfr':'\uD835\uDD2B','Nfr':'\uD835\uDD11','nge':'\u2271','ngE':'\u2267\u0338','ngeq':'\u2271','ngeqq':'\u2267\u0338','ngeqslant':'\u2A7E\u0338','nges':'\u2A7E\u0338','nGg':'\u22D9\u0338','ngsim':'\u2275','ngt':'\u226F','nGt':'\u226B\u20D2','ngtr':'\u226F','nGtv':'\u226B\u0338','nharr':'\u21AE','nhArr':'\u21CE','nhpar':'\u2AF2','ni':'\u220B','nis':'\u22FC','nisd':'\u22FA','niv':'\u220B','njcy':'\u045A','NJcy':'\u040A','nlarr':'\u219A','nlArr':'\u21CD','nldr':'\u2025','nle':'\u2270','nlE':'\u2266\u0338','nleftarrow':'\u219A','nLeftarrow':'\u21CD','nleftrightarrow':'\u21AE','nLeftrightarrow':'\u21CE','nleq':'\u2270','nleqq':'\u2266\u0338','nleqslant':'\u2A7D\u0338','nles':'\u2A7D\u0338','nless':'\u226E','nLl':'\u22D8\u0338','nlsim':'\u2274','nlt':'\u226E','nLt':'\u226A\u20D2','nltri':'\u22EA','nltrie':'\u22EC','nLtv':'\u226A\u0338','nmid':'\u2224','NoBreak':'\u2060','NonBreakingSpace':'\xA0','nopf':'\uD835\uDD5F','Nopf':'\u2115','not':'\xAC','Not':'\u2AEC','NotCongruent':'\u2262','NotCupCap':'\u226D','NotDoubleVerticalBar':'\u2226','NotElement':'\u2209','NotEqual':'\u2260','NotEqualTilde':'\u2242\u0338','NotExists':'\u2204','NotGreater':'\u226F','NotGreaterEqual':'\u2271','NotGreaterFullEqual':'\u2267\u0338','NotGreaterGreater':'\u226B\u0338','NotGreaterLess':'\u2279','NotGreaterSlantEqual':'\u2A7E\u0338','NotGreaterTilde':'\u2275','NotHumpDownHump':'\u224E\u0338','NotHumpEqual':'\u224F\u0338','notin':'\u2209','notindot':'\u22F5\u0338','notinE':'\u22F9\u0338','notinva':'\u2209','notinvb':'\u22F7','notinvc':'\u22F6','NotLeftTriangle':'\u22EA','NotLeftTriangleBar':'\u29CF\u0338','NotLeftTriangleEqual':'\u22EC','NotLess':'\u226E','NotLessEqual':'\u2270','NotLessGreater':'\u2278','NotLessLess':'\u226A\u0338','NotLessSlantEqual':'\u2A7D\u0338','NotLessTilde':'\u2274','NotNestedGreaterGreater':'\u2AA2\u0338','NotNestedLessLess':'\u2AA1\u0338','notni':'\u220C','notniva':'\u220C','notnivb':'\u22FE','notnivc':'\u22FD','NotPrecedes':'\u2280','NotPrecedesEqual':'\u2AAF\u0338','NotPrecedesSlantEqual':'\u22E0','NotReverseElement':'\u220C','NotRightTriangle':'\u22EB','NotRightTriangleBar':'\u29D0\u0338','NotRightTriangleEqual':'\u22ED','NotSquareSubset':'\u228F\u0338','NotSquareSubsetEqual':'\u22E2','NotSquareSuperset':'\u2290\u0338','NotSquareSupersetEqual':'\u22E3','NotSubset':'\u2282\u20D2','NotSubsetEqual':'\u2288','NotSucceeds':'\u2281','NotSucceedsEqual':'\u2AB0\u0338','NotSucceedsSlantEqual':'\u22E1','NotSucceedsTilde':'\u227F\u0338','NotSuperset':'\u2283\u20D2','NotSupersetEqual':'\u2289','NotTilde':'\u2241','NotTildeEqual':'\u2244','NotTildeFullEqual':'\u2247','NotTildeTilde':'\u2249','NotVerticalBar':'\u2224','npar':'\u2226','nparallel':'\u2226','nparsl':'\u2AFD\u20E5','npart':'\u2202\u0338','npolint':'\u2A14','npr':'\u2280','nprcue':'\u22E0','npre':'\u2AAF\u0338','nprec':'\u2280','npreceq':'\u2AAF\u0338','nrarr':'\u219B','nrArr':'\u21CF','nrarrc':'\u2933\u0338','nrarrw':'\u219D\u0338','nrightarrow':'\u219B','nRightarrow':'\u21CF','nrtri':'\u22EB','nrtrie':'\u22ED','nsc':'\u2281','nsccue':'\u22E1','nsce':'\u2AB0\u0338','nscr':'\uD835\uDCC3','Nscr':'\uD835\uDCA9','nshortmid':'\u2224','nshortparallel':'\u2226','nsim':'\u2241','nsime':'\u2244','nsimeq':'\u2244','nsmid':'\u2224','nspar':'\u2226','nsqsube':'\u22E2','nsqsupe':'\u22E3','nsub':'\u2284','nsube':'\u2288','nsubE':'\u2AC5\u0338','nsubset':'\u2282\u20D2','nsubseteq':'\u2288','nsubseteqq':'\u2AC5\u0338','nsucc':'\u2281','nsucceq':'\u2AB0\u0338','nsup':'\u2285','nsupe':'\u2289','nsupE':'\u2AC6\u0338','nsupset':'\u2283\u20D2','nsupseteq':'\u2289','nsupseteqq':'\u2AC6\u0338','ntgl':'\u2279','ntilde':'\xF1','Ntilde':'\xD1','ntlg':'\u2278','ntriangleleft':'\u22EA','ntrianglelefteq':'\u22EC','ntriangleright':'\u22EB','ntrianglerighteq':'\u22ED','nu':'\u03BD','Nu':'\u039D','num':'#','numero':'\u2116','numsp':'\u2007','nvap':'\u224D\u20D2','nvdash':'\u22AC','nvDash':'\u22AD','nVdash':'\u22AE','nVDash':'\u22AF','nvge':'\u2265\u20D2','nvgt':'>\u20D2','nvHarr':'\u2904','nvinfin':'\u29DE','nvlArr':'\u2902','nvle':'\u2264\u20D2','nvlt':'<\u20D2','nvltrie':'\u22B4\u20D2','nvrArr':'\u2903','nvrtrie':'\u22B5\u20D2','nvsim':'\u223C\u20D2','nwarhk':'\u2923','nwarr':'\u2196','nwArr':'\u21D6','nwarrow':'\u2196','nwnear':'\u2927','oacute':'\xF3','Oacute':'\xD3','oast':'\u229B','ocir':'\u229A','ocirc':'\xF4','Ocirc':'\xD4','ocy':'\u043E','Ocy':'\u041E','odash':'\u229D','odblac':'\u0151','Odblac':'\u0150','odiv':'\u2A38','odot':'\u2299','odsold':'\u29BC','oelig':'\u0153','OElig':'\u0152','ofcir':'\u29BF','ofr':'\uD835\uDD2C','Ofr':'\uD835\uDD12','ogon':'\u02DB','ograve':'\xF2','Ograve':'\xD2','ogt':'\u29C1','ohbar':'\u29B5','ohm':'\u03A9','oint':'\u222E','olarr':'\u21BA','olcir':'\u29BE','olcross':'\u29BB','oline':'\u203E','olt':'\u29C0','omacr':'\u014D','Omacr':'\u014C','omega':'\u03C9','Omega':'\u03A9','omicron':'\u03BF','Omicron':'\u039F','omid':'\u29B6','ominus':'\u2296','oopf':'\uD835\uDD60','Oopf':'\uD835\uDD46','opar':'\u29B7','OpenCurlyDoubleQuote':'\u201C','OpenCurlyQuote':'\u2018','operp':'\u29B9','oplus':'\u2295','or':'\u2228','Or':'\u2A54','orarr':'\u21BB','ord':'\u2A5D','order':'\u2134','orderof':'\u2134','ordf':'\xAA','ordm':'\xBA','origof':'\u22B6','oror':'\u2A56','orslope':'\u2A57','orv':'\u2A5B','oS':'\u24C8','oscr':'\u2134','Oscr':'\uD835\uDCAA','oslash':'\xF8','Oslash':'\xD8','osol':'\u2298','otilde':'\xF5','Otilde':'\xD5','otimes':'\u2297','Otimes':'\u2A37','otimesas':'\u2A36','ouml':'\xF6','Ouml':'\xD6','ovbar':'\u233D','OverBar':'\u203E','OverBrace':'\u23DE','OverBracket':'\u23B4','OverParenthesis':'\u23DC','par':'\u2225','para':'\xB6','parallel':'\u2225','parsim':'\u2AF3','parsl':'\u2AFD','part':'\u2202','PartialD':'\u2202','pcy':'\u043F','Pcy':'\u041F','percnt':'%','period':'.','permil':'\u2030','perp':'\u22A5','pertenk':'\u2031','pfr':'\uD835\uDD2D','Pfr':'\uD835\uDD13','phi':'\u03C6','Phi':'\u03A6','phiv':'\u03D5','phmmat':'\u2133','phone':'\u260E','pi':'\u03C0','Pi':'\u03A0','pitchfork':'\u22D4','piv':'\u03D6','planck':'\u210F','planckh':'\u210E','plankv':'\u210F','plus':'+','plusacir':'\u2A23','plusb':'\u229E','pluscir':'\u2A22','plusdo':'\u2214','plusdu':'\u2A25','pluse':'\u2A72','PlusMinus':'\xB1','plusmn':'\xB1','plussim':'\u2A26','plustwo':'\u2A27','pm':'\xB1','Poincareplane':'\u210C','pointint':'\u2A15','popf':'\uD835\uDD61','Popf':'\u2119','pound':'\xA3','pr':'\u227A','Pr':'\u2ABB','prap':'\u2AB7','prcue':'\u227C','pre':'\u2AAF','prE':'\u2AB3','prec':'\u227A','precapprox':'\u2AB7','preccurlyeq':'\u227C','Precedes':'\u227A','PrecedesEqual':'\u2AAF','PrecedesSlantEqual':'\u227C','PrecedesTilde':'\u227E','preceq':'\u2AAF','precnapprox':'\u2AB9','precneqq':'\u2AB5','precnsim':'\u22E8','precsim':'\u227E','prime':'\u2032','Prime':'\u2033','primes':'\u2119','prnap':'\u2AB9','prnE':'\u2AB5','prnsim':'\u22E8','prod':'\u220F','Product':'\u220F','profalar':'\u232E','profline':'\u2312','profsurf':'\u2313','prop':'\u221D','Proportion':'\u2237','Proportional':'\u221D','propto':'\u221D','prsim':'\u227E','prurel':'\u22B0','pscr':'\uD835\uDCC5','Pscr':'\uD835\uDCAB','psi':'\u03C8','Psi':'\u03A8','puncsp':'\u2008','qfr':'\uD835\uDD2E','Qfr':'\uD835\uDD14','qint':'\u2A0C','qopf':'\uD835\uDD62','Qopf':'\u211A','qprime':'\u2057','qscr':'\uD835\uDCC6','Qscr':'\uD835\uDCAC','quaternions':'\u210D','quatint':'\u2A16','quest':'?','questeq':'\u225F','quot':'"','QUOT':'"','rAarr':'\u21DB','race':'\u223D\u0331','racute':'\u0155','Racute':'\u0154','radic':'\u221A','raemptyv':'\u29B3','rang':'\u27E9','Rang':'\u27EB','rangd':'\u2992','range':'\u29A5','rangle':'\u27E9','raquo':'\xBB','rarr':'\u2192','rArr':'\u21D2','Rarr':'\u21A0','rarrap':'\u2975','rarrb':'\u21E5','rarrbfs':'\u2920','rarrc':'\u2933','rarrfs':'\u291E','rarrhk':'\u21AA','rarrlp':'\u21AC','rarrpl':'\u2945','rarrsim':'\u2974','rarrtl':'\u21A3','Rarrtl':'\u2916','rarrw':'\u219D','ratail':'\u291A','rAtail':'\u291C','ratio':'\u2236','rationals':'\u211A','rbarr':'\u290D','rBarr':'\u290F','RBarr':'\u2910','rbbrk':'\u2773','rbrace':'}','rbrack':']','rbrke':'\u298C','rbrksld':'\u298E','rbrkslu':'\u2990','rcaron':'\u0159','Rcaron':'\u0158','rcedil':'\u0157','Rcedil':'\u0156','rceil':'\u2309','rcub':'}','rcy':'\u0440','Rcy':'\u0420','rdca':'\u2937','rdldhar':'\u2969','rdquo':'\u201D','rdquor':'\u201D','rdsh':'\u21B3','Re':'\u211C','real':'\u211C','realine':'\u211B','realpart':'\u211C','reals':'\u211D','rect':'\u25AD','reg':'\xAE','REG':'\xAE','ReverseElement':'\u220B','ReverseEquilibrium':'\u21CB','ReverseUpEquilibrium':'\u296F','rfisht':'\u297D','rfloor':'\u230B','rfr':'\uD835\uDD2F','Rfr':'\u211C','rHar':'\u2964','rhard':'\u21C1','rharu':'\u21C0','rharul':'\u296C','rho':'\u03C1','Rho':'\u03A1','rhov':'\u03F1','RightAngleBracket':'\u27E9','rightarrow':'\u2192','Rightarrow':'\u21D2','RightArrow':'\u2192','RightArrowBar':'\u21E5','RightArrowLeftArrow':'\u21C4','rightarrowtail':'\u21A3','RightCeiling':'\u2309','RightDoubleBracket':'\u27E7','RightDownTeeVector':'\u295D','RightDownVector':'\u21C2','RightDownVectorBar':'\u2955','RightFloor':'\u230B','rightharpoondown':'\u21C1','rightharpoonup':'\u21C0','rightleftarrows':'\u21C4','rightleftharpoons':'\u21CC','rightrightarrows':'\u21C9','rightsquigarrow':'\u219D','RightTee':'\u22A2','RightTeeArrow':'\u21A6','RightTeeVector':'\u295B','rightthreetimes':'\u22CC','RightTriangle':'\u22B3','RightTriangleBar':'\u29D0','RightTriangleEqual':'\u22B5','RightUpDownVector':'\u294F','RightUpTeeVector':'\u295C','RightUpVector':'\u21BE','RightUpVectorBar':'\u2954','RightVector':'\u21C0','RightVectorBar':'\u2953','ring':'\u02DA','risingdotseq':'\u2253','rlarr':'\u21C4','rlhar':'\u21CC','rlm':'\u200F','rmoust':'\u23B1','rmoustache':'\u23B1','rnmid':'\u2AEE','roang':'\u27ED','roarr':'\u21FE','robrk':'\u27E7','ropar':'\u2986','ropf':'\uD835\uDD63','Ropf':'\u211D','roplus':'\u2A2E','rotimes':'\u2A35','RoundImplies':'\u2970','rpar':')','rpargt':'\u2994','rppolint':'\u2A12','rrarr':'\u21C9','Rrightarrow':'\u21DB','rsaquo':'\u203A','rscr':'\uD835\uDCC7','Rscr':'\u211B','rsh':'\u21B1','Rsh':'\u21B1','rsqb':']','rsquo':'\u2019','rsquor':'\u2019','rthree':'\u22CC','rtimes':'\u22CA','rtri':'\u25B9','rtrie':'\u22B5','rtrif':'\u25B8','rtriltri':'\u29CE','RuleDelayed':'\u29F4','ruluhar':'\u2968','rx':'\u211E','sacute':'\u015B','Sacute':'\u015A','sbquo':'\u201A','sc':'\u227B','Sc':'\u2ABC','scap':'\u2AB8','scaron':'\u0161','Scaron':'\u0160','sccue':'\u227D','sce':'\u2AB0','scE':'\u2AB4','scedil':'\u015F','Scedil':'\u015E','scirc':'\u015D','Scirc':'\u015C','scnap':'\u2ABA','scnE':'\u2AB6','scnsim':'\u22E9','scpolint':'\u2A13','scsim':'\u227F','scy':'\u0441','Scy':'\u0421','sdot':'\u22C5','sdotb':'\u22A1','sdote':'\u2A66','searhk':'\u2925','searr':'\u2198','seArr':'\u21D8','searrow':'\u2198','sect':'\xA7','semi':';','seswar':'\u2929','setminus':'\u2216','setmn':'\u2216','sext':'\u2736','sfr':'\uD835\uDD30','Sfr':'\uD835\uDD16','sfrown':'\u2322','sharp':'\u266F','shchcy':'\u0449','SHCHcy':'\u0429','shcy':'\u0448','SHcy':'\u0428','ShortDownArrow':'\u2193','ShortLeftArrow':'\u2190','shortmid':'\u2223','shortparallel':'\u2225','ShortRightArrow':'\u2192','ShortUpArrow':'\u2191','shy':'\xAD','sigma':'\u03C3','Sigma':'\u03A3','sigmaf':'\u03C2','sigmav':'\u03C2','sim':'\u223C','simdot':'\u2A6A','sime':'\u2243','simeq':'\u2243','simg':'\u2A9E','simgE':'\u2AA0','siml':'\u2A9D','simlE':'\u2A9F','simne':'\u2246','simplus':'\u2A24','simrarr':'\u2972','slarr':'\u2190','SmallCircle':'\u2218','smallsetminus':'\u2216','smashp':'\u2A33','smeparsl':'\u29E4','smid':'\u2223','smile':'\u2323','smt':'\u2AAA','smte':'\u2AAC','smtes':'\u2AAC\uFE00','softcy':'\u044C','SOFTcy':'\u042C','sol':'/','solb':'\u29C4','solbar':'\u233F','sopf':'\uD835\uDD64','Sopf':'\uD835\uDD4A','spades':'\u2660','spadesuit':'\u2660','spar':'\u2225','sqcap':'\u2293','sqcaps':'\u2293\uFE00','sqcup':'\u2294','sqcups':'\u2294\uFE00','Sqrt':'\u221A','sqsub':'\u228F','sqsube':'\u2291','sqsubset':'\u228F','sqsubseteq':'\u2291','sqsup':'\u2290','sqsupe':'\u2292','sqsupset':'\u2290','sqsupseteq':'\u2292','squ':'\u25A1','square':'\u25A1','Square':'\u25A1','SquareIntersection':'\u2293','SquareSubset':'\u228F','SquareSubsetEqual':'\u2291','SquareSuperset':'\u2290','SquareSupersetEqual':'\u2292','SquareUnion':'\u2294','squarf':'\u25AA','squf':'\u25AA','srarr':'\u2192','sscr':'\uD835\uDCC8','Sscr':'\uD835\uDCAE','ssetmn':'\u2216','ssmile':'\u2323','sstarf':'\u22C6','star':'\u2606','Star':'\u22C6','starf':'\u2605','straightepsilon':'\u03F5','straightphi':'\u03D5','strns':'\xAF','sub':'\u2282','Sub':'\u22D0','subdot':'\u2ABD','sube':'\u2286','subE':'\u2AC5','subedot':'\u2AC3','submult':'\u2AC1','subne':'\u228A','subnE':'\u2ACB','subplus':'\u2ABF','subrarr':'\u2979','subset':'\u2282','Subset':'\u22D0','subseteq':'\u2286','subseteqq':'\u2AC5','SubsetEqual':'\u2286','subsetneq':'\u228A','subsetneqq':'\u2ACB','subsim':'\u2AC7','subsub':'\u2AD5','subsup':'\u2AD3','succ':'\u227B','succapprox':'\u2AB8','succcurlyeq':'\u227D','Succeeds':'\u227B','SucceedsEqual':'\u2AB0','SucceedsSlantEqual':'\u227D','SucceedsTilde':'\u227F','succeq':'\u2AB0','succnapprox':'\u2ABA','succneqq':'\u2AB6','succnsim':'\u22E9','succsim':'\u227F','SuchThat':'\u220B','sum':'\u2211','Sum':'\u2211','sung':'\u266A','sup':'\u2283','Sup':'\u22D1','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','supdot':'\u2ABE','supdsub':'\u2AD8','supe':'\u2287','supE':'\u2AC6','supedot':'\u2AC4','Superset':'\u2283','SupersetEqual':'\u2287','suphsol':'\u27C9','suphsub':'\u2AD7','suplarr':'\u297B','supmult':'\u2AC2','supne':'\u228B','supnE':'\u2ACC','supplus':'\u2AC0','supset':'\u2283','Supset':'\u22D1','supseteq':'\u2287','supseteqq':'\u2AC6','supsetneq':'\u228B','supsetneqq':'\u2ACC','supsim':'\u2AC8','supsub':'\u2AD4','supsup':'\u2AD6','swarhk':'\u2926','swarr':'\u2199','swArr':'\u21D9','swarrow':'\u2199','swnwar':'\u292A','szlig':'\xDF','Tab':'\t','target':'\u2316','tau':'\u03C4','Tau':'\u03A4','tbrk':'\u23B4','tcaron':'\u0165','Tcaron':'\u0164','tcedil':'\u0163','Tcedil':'\u0162','tcy':'\u0442','Tcy':'\u0422','tdot':'\u20DB','telrec':'\u2315','tfr':'\uD835\uDD31','Tfr':'\uD835\uDD17','there4':'\u2234','therefore':'\u2234','Therefore':'\u2234','theta':'\u03B8','Theta':'\u0398','thetasym':'\u03D1','thetav':'\u03D1','thickapprox':'\u2248','thicksim':'\u223C','ThickSpace':'\u205F\u200A','thinsp':'\u2009','ThinSpace':'\u2009','thkap':'\u2248','thksim':'\u223C','thorn':'\xFE','THORN':'\xDE','tilde':'\u02DC','Tilde':'\u223C','TildeEqual':'\u2243','TildeFullEqual':'\u2245','TildeTilde':'\u2248','times':'\xD7','timesb':'\u22A0','timesbar':'\u2A31','timesd':'\u2A30','tint':'\u222D','toea':'\u2928','top':'\u22A4','topbot':'\u2336','topcir':'\u2AF1','topf':'\uD835\uDD65','Topf':'\uD835\uDD4B','topfork':'\u2ADA','tosa':'\u2929','tprime':'\u2034','trade':'\u2122','TRADE':'\u2122','triangle':'\u25B5','triangledown':'\u25BF','triangleleft':'\u25C3','trianglelefteq':'\u22B4','triangleq':'\u225C','triangleright':'\u25B9','trianglerighteq':'\u22B5','tridot':'\u25EC','trie':'\u225C','triminus':'\u2A3A','TripleDot':'\u20DB','triplus':'\u2A39','trisb':'\u29CD','tritime':'\u2A3B','trpezium':'\u23E2','tscr':'\uD835\uDCC9','Tscr':'\uD835\uDCAF','tscy':'\u0446','TScy':'\u0426','tshcy':'\u045B','TSHcy':'\u040B','tstrok':'\u0167','Tstrok':'\u0166','twixt':'\u226C','twoheadleftarrow':'\u219E','twoheadrightarrow':'\u21A0','uacute':'\xFA','Uacute':'\xDA','uarr':'\u2191','uArr':'\u21D1','Uarr':'\u219F','Uarrocir':'\u2949','ubrcy':'\u045E','Ubrcy':'\u040E','ubreve':'\u016D','Ubreve':'\u016C','ucirc':'\xFB','Ucirc':'\xDB','ucy':'\u0443','Ucy':'\u0423','udarr':'\u21C5','udblac':'\u0171','Udblac':'\u0170','udhar':'\u296E','ufisht':'\u297E','ufr':'\uD835\uDD32','Ufr':'\uD835\uDD18','ugrave':'\xF9','Ugrave':'\xD9','uHar':'\u2963','uharl':'\u21BF','uharr':'\u21BE','uhblk':'\u2580','ulcorn':'\u231C','ulcorner':'\u231C','ulcrop':'\u230F','ultri':'\u25F8','umacr':'\u016B','Umacr':'\u016A','uml':'\xA8','UnderBar':'_','UnderBrace':'\u23DF','UnderBracket':'\u23B5','UnderParenthesis':'\u23DD','Union':'\u22C3','UnionPlus':'\u228E','uogon':'\u0173','Uogon':'\u0172','uopf':'\uD835\uDD66','Uopf':'\uD835\uDD4C','uparrow':'\u2191','Uparrow':'\u21D1','UpArrow':'\u2191','UpArrowBar':'\u2912','UpArrowDownArrow':'\u21C5','updownarrow':'\u2195','Updownarrow':'\u21D5','UpDownArrow':'\u2195','UpEquilibrium':'\u296E','upharpoonleft':'\u21BF','upharpoonright':'\u21BE','uplus':'\u228E','UpperLeftArrow':'\u2196','UpperRightArrow':'\u2197','upsi':'\u03C5','Upsi':'\u03D2','upsih':'\u03D2','upsilon':'\u03C5','Upsilon':'\u03A5','UpTee':'\u22A5','UpTeeArrow':'\u21A5','upuparrows':'\u21C8','urcorn':'\u231D','urcorner':'\u231D','urcrop':'\u230E','uring':'\u016F','Uring':'\u016E','urtri':'\u25F9','uscr':'\uD835\uDCCA','Uscr':'\uD835\uDCB0','utdot':'\u22F0','utilde':'\u0169','Utilde':'\u0168','utri':'\u25B5','utrif':'\u25B4','uuarr':'\u21C8','uuml':'\xFC','Uuml':'\xDC','uwangle':'\u29A7','vangrt':'\u299C','varepsilon':'\u03F5','varkappa':'\u03F0','varnothing':'\u2205','varphi':'\u03D5','varpi':'\u03D6','varpropto':'\u221D','varr':'\u2195','vArr':'\u21D5','varrho':'\u03F1','varsigma':'\u03C2','varsubsetneq':'\u228A\uFE00','varsubsetneqq':'\u2ACB\uFE00','varsupsetneq':'\u228B\uFE00','varsupsetneqq':'\u2ACC\uFE00','vartheta':'\u03D1','vartriangleleft':'\u22B2','vartriangleright':'\u22B3','vBar':'\u2AE8','Vbar':'\u2AEB','vBarv':'\u2AE9','vcy':'\u0432','Vcy':'\u0412','vdash':'\u22A2','vDash':'\u22A8','Vdash':'\u22A9','VDash':'\u22AB','Vdashl':'\u2AE6','vee':'\u2228','Vee':'\u22C1','veebar':'\u22BB','veeeq':'\u225A','vellip':'\u22EE','verbar':'|','Verbar':'\u2016','vert':'|','Vert':'\u2016','VerticalBar':'\u2223','VerticalLine':'|','VerticalSeparator':'\u2758','VerticalTilde':'\u2240','VeryThinSpace':'\u200A','vfr':'\uD835\uDD33','Vfr':'\uD835\uDD19','vltri':'\u22B2','vnsub':'\u2282\u20D2','vnsup':'\u2283\u20D2','vopf':'\uD835\uDD67','Vopf':'\uD835\uDD4D','vprop':'\u221D','vrtri':'\u22B3','vscr':'\uD835\uDCCB','Vscr':'\uD835\uDCB1','vsubne':'\u228A\uFE00','vsubnE':'\u2ACB\uFE00','vsupne':'\u228B\uFE00','vsupnE':'\u2ACC\uFE00','Vvdash':'\u22AA','vzigzag':'\u299A','wcirc':'\u0175','Wcirc':'\u0174','wedbar':'\u2A5F','wedge':'\u2227','Wedge':'\u22C0','wedgeq':'\u2259','weierp':'\u2118','wfr':'\uD835\uDD34','Wfr':'\uD835\uDD1A','wopf':'\uD835\uDD68','Wopf':'\uD835\uDD4E','wp':'\u2118','wr':'\u2240','wreath':'\u2240','wscr':'\uD835\uDCCC','Wscr':'\uD835\uDCB2','xcap':'\u22C2','xcirc':'\u25EF','xcup':'\u22C3','xdtri':'\u25BD','xfr':'\uD835\uDD35','Xfr':'\uD835\uDD1B','xharr':'\u27F7','xhArr':'\u27FA','xi':'\u03BE','Xi':'\u039E','xlarr':'\u27F5','xlArr':'\u27F8','xmap':'\u27FC','xnis':'\u22FB','xodot':'\u2A00','xopf':'\uD835\uDD69','Xopf':'\uD835\uDD4F','xoplus':'\u2A01','xotime':'\u2A02','xrarr':'\u27F6','xrArr':'\u27F9','xscr':'\uD835\uDCCD','Xscr':'\uD835\uDCB3','xsqcup':'\u2A06','xuplus':'\u2A04','xutri':'\u25B3','xvee':'\u22C1','xwedge':'\u22C0','yacute':'\xFD','Yacute':'\xDD','yacy':'\u044F','YAcy':'\u042F','ycirc':'\u0177','Ycirc':'\u0176','ycy':'\u044B','Ycy':'\u042B','yen':'\xA5','yfr':'\uD835\uDD36','Yfr':'\uD835\uDD1C','yicy':'\u0457','YIcy':'\u0407','yopf':'\uD835\uDD6A','Yopf':'\uD835\uDD50','yscr':'\uD835\uDCCE','Yscr':'\uD835\uDCB4','yucy':'\u044E','YUcy':'\u042E','yuml':'\xFF','Yuml':'\u0178','zacute':'\u017A','Zacute':'\u0179','zcaron':'\u017E','Zcaron':'\u017D','zcy':'\u0437','Zcy':'\u0417','zdot':'\u017C','Zdot':'\u017B','zeetrf':'\u2128','ZeroWidthSpace':'\u200B','zeta':'\u03B6','Zeta':'\u0396','zfr':'\uD835\uDD37','Zfr':'\u2128','zhcy':'\u0436','ZHcy':'\u0416','zigrarr':'\u21DD','zopf':'\uD835\uDD6B','Zopf':'\u2124','zscr':'\uD835\uDCCF','Zscr':'\uD835\uDCB5','zwj':'\u200D','zwnj':'\u200C'};
  	var decodeMapLegacy = {'aacute':'\xE1','Aacute':'\xC1','acirc':'\xE2','Acirc':'\xC2','acute':'\xB4','aelig':'\xE6','AElig':'\xC6','agrave':'\xE0','Agrave':'\xC0','amp':'&','AMP':'&','aring':'\xE5','Aring':'\xC5','atilde':'\xE3','Atilde':'\xC3','auml':'\xE4','Auml':'\xC4','brvbar':'\xA6','ccedil':'\xE7','Ccedil':'\xC7','cedil':'\xB8','cent':'\xA2','copy':'\xA9','COPY':'\xA9','curren':'\xA4','deg':'\xB0','divide':'\xF7','eacute':'\xE9','Eacute':'\xC9','ecirc':'\xEA','Ecirc':'\xCA','egrave':'\xE8','Egrave':'\xC8','eth':'\xF0','ETH':'\xD0','euml':'\xEB','Euml':'\xCB','frac12':'\xBD','frac14':'\xBC','frac34':'\xBE','gt':'>','GT':'>','iacute':'\xED','Iacute':'\xCD','icirc':'\xEE','Icirc':'\xCE','iexcl':'\xA1','igrave':'\xEC','Igrave':'\xCC','iquest':'\xBF','iuml':'\xEF','Iuml':'\xCF','laquo':'\xAB','lt':'<','LT':'<','macr':'\xAF','micro':'\xB5','middot':'\xB7','nbsp':'\xA0','not':'\xAC','ntilde':'\xF1','Ntilde':'\xD1','oacute':'\xF3','Oacute':'\xD3','ocirc':'\xF4','Ocirc':'\xD4','ograve':'\xF2','Ograve':'\xD2','ordf':'\xAA','ordm':'\xBA','oslash':'\xF8','Oslash':'\xD8','otilde':'\xF5','Otilde':'\xD5','ouml':'\xF6','Ouml':'\xD6','para':'\xB6','plusmn':'\xB1','pound':'\xA3','quot':'"','QUOT':'"','raquo':'\xBB','reg':'\xAE','REG':'\xAE','sect':'\xA7','shy':'\xAD','sup1':'\xB9','sup2':'\xB2','sup3':'\xB3','szlig':'\xDF','thorn':'\xFE','THORN':'\xDE','times':'\xD7','uacute':'\xFA','Uacute':'\xDA','ucirc':'\xFB','Ucirc':'\xDB','ugrave':'\xF9','Ugrave':'\xD9','uml':'\xA8','uuml':'\xFC','Uuml':'\xDC','yacute':'\xFD','Yacute':'\xDD','yen':'\xA5','yuml':'\xFF'};
  	var decodeMapNumeric = {'0':'\uFFFD','128':'\u20AC','130':'\u201A','131':'\u0192','132':'\u201E','133':'\u2026','134':'\u2020','135':'\u2021','136':'\u02C6','137':'\u2030','138':'\u0160','139':'\u2039','140':'\u0152','142':'\u017D','145':'\u2018','146':'\u2019','147':'\u201C','148':'\u201D','149':'\u2022','150':'\u2013','151':'\u2014','152':'\u02DC','153':'\u2122','154':'\u0161','155':'\u203A','156':'\u0153','158':'\u017E','159':'\u0178'};
  	var invalidReferenceCodePoints = [1,2,3,4,5,6,7,8,11,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,64976,64977,64978,64979,64980,64981,64982,64983,64984,64985,64986,64987,64988,64989,64990,64991,64992,64993,64994,64995,64996,64997,64998,64999,65000,65001,65002,65003,65004,65005,65006,65007,65534,65535,131070,131071,196606,196607,262142,262143,327678,327679,393214,393215,458750,458751,524286,524287,589822,589823,655358,655359,720894,720895,786430,786431,851966,851967,917502,917503,983038,983039,1048574,1048575,1114110,1114111];
  
  	/*--------------------------------------------------------------------------*/
  
  	var stringFromCharCode = String.fromCharCode;
  
  	var object = {};
  	var hasOwnProperty = object.hasOwnProperty;
  	var has = function(object, propertyName) {
  		return hasOwnProperty.call(object, propertyName);
  	};
  
  	var contains = function(array, value) {
  		var index = -1;
  		var length = array.length;
  		while (++index < length) {
  			if (array[index] == value) {
  				return true;
  			}
  		}
  		return false;
  	};
  
  	var merge = function(options, defaults) {
  		if (!options) {
  			return defaults;
  		}
  		var result = {};
  		var key;
  		for (key in defaults) {
  			// A `hasOwnProperty` check is not needed here, since only recognized
  			// option names are used anyway. Any others are ignored.
  			result[key] = has(options, key) ? options[key] : defaults[key];
  		}
  		return result;
  	};
  
  	// Modified version of `ucs2encode`; see https://mths.be/punycode.
  	var codePointToSymbol = function(codePoint, strict) {
  		var output = '';
  		if ((codePoint >= 0xD800 && codePoint <= 0xDFFF) || codePoint > 0x10FFFF) {
  			// See issue #4:
  			// “Otherwise, if the number is in the range 0xD800 to 0xDFFF or is
  			// greater than 0x10FFFF, then this is a parse error. Return a U+FFFD
  			// REPLACEMENT CHARACTER.”
  			if (strict) {
  				parseError('character reference outside the permissible Unicode range');
  			}
  			return '\uFFFD';
  		}
  		if (has(decodeMapNumeric, codePoint)) {
  			if (strict) {
  				parseError('disallowed character reference');
  			}
  			return decodeMapNumeric[codePoint];
  		}
  		if (strict && contains(invalidReferenceCodePoints, codePoint)) {
  			parseError('disallowed character reference');
  		}
  		if (codePoint > 0xFFFF) {
  			codePoint -= 0x10000;
  			output += stringFromCharCode(codePoint >>> 10 & 0x3FF | 0xD800);
  			codePoint = 0xDC00 | codePoint & 0x3FF;
  		}
  		output += stringFromCharCode(codePoint);
  		return output;
  	};
  
  	var hexEscape = function(codePoint) {
  		return '&#x' + codePoint.toString(16).toUpperCase() + ';';
  	};
  
  	var decEscape = function(codePoint) {
  		return '&#' + codePoint + ';';
  	};
  
  	var parseError = function(message) {
  		throw Error('Parse error: ' + message);
  	};
  
  	/*--------------------------------------------------------------------------*/
  
  	var encode = function(string, options) {
  		options = merge(options, encode.options);
  		var strict = options.strict;
  		if (strict && regexInvalidRawCodePoint.test(string)) {
  			parseError('forbidden code point');
  		}
  		var encodeEverything = options.encodeEverything;
  		var useNamedReferences = options.useNamedReferences;
  		var allowUnsafeSymbols = options.allowUnsafeSymbols;
  		var escapeCodePoint = options.decimal ? decEscape : hexEscape;
  
  		var escapeBmpSymbol = function(symbol) {
  			return escapeCodePoint(symbol.charCodeAt(0));
  		};
  
  		if (encodeEverything) {
  			// Encode ASCII symbols.
  			string = string.replace(regexAsciiWhitelist, function(symbol) {
  				// Use named references if requested & possible.
  				if (useNamedReferences && has(encodeMap, symbol)) {
  					return '&' + encodeMap[symbol] + ';';
  				}
  				return escapeBmpSymbol(symbol);
  			});
  			// Shorten a few escapes that represent two symbols, of which at least one
  			// is within the ASCII range.
  			if (useNamedReferences) {
  				string = string
  					.replace(/&gt;\u20D2/g, '&nvgt;')
  					.replace(/&lt;\u20D2/g, '&nvlt;')
  					.replace(/&#x66;&#x6A;/g, '&fjlig;');
  			}
  			// Encode non-ASCII symbols.
  			if (useNamedReferences) {
  				// Encode non-ASCII symbols that can be replaced with a named reference.
  				string = string.replace(regexEncodeNonAscii, function(string) {
  					// Note: there is no need to check `has(encodeMap, string)` here.
  					return '&' + encodeMap[string] + ';';
  				});
  			}
  			// Note: any remaining non-ASCII symbols are handled outside of the `if`.
  		} else if (useNamedReferences) {
  			// Apply named character references.
  			// Encode `<>"'&` using named character references.
  			if (!allowUnsafeSymbols) {
  				string = string.replace(regexEscape, function(string) {
  					return '&' + encodeMap[string] + ';'; // no need to check `has()` here
  				});
  			}
  			// Shorten escapes that represent two symbols, of which at least one is
  			// `<>"'&`.
  			string = string
  				.replace(/&gt;\u20D2/g, '&nvgt;')
  				.replace(/&lt;\u20D2/g, '&nvlt;');
  			// Encode non-ASCII symbols that can be replaced with a named reference.
  			string = string.replace(regexEncodeNonAscii, function(string) {
  				// Note: there is no need to check `has(encodeMap, string)` here.
  				return '&' + encodeMap[string] + ';';
  			});
  		} else if (!allowUnsafeSymbols) {
  			// Encode `<>"'&` using hexadecimal escapes, now that they’re not handled
  			// using named character references.
  			string = string.replace(regexEscape, escapeBmpSymbol);
  		}
  		return string
  			// Encode astral symbols.
  			.replace(regexAstralSymbols, function($0) {
  				// https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
  				var high = $0.charCodeAt(0);
  				var low = $0.charCodeAt(1);
  				var codePoint = (high - 0xD800) * 0x400 + low - 0xDC00 + 0x10000;
  				return escapeCodePoint(codePoint);
  			})
  			// Encode any remaining BMP symbols that are not printable ASCII symbols
  			// using a hexadecimal escape.
  			.replace(regexBmpWhitelist, escapeBmpSymbol);
  	};
  	// Expose default options (so they can be overridden globally).
  	encode.options = {
  		'allowUnsafeSymbols': false,
  		'encodeEverything': false,
  		'strict': false,
  		'useNamedReferences': false,
  		'decimal' : false
  	};
  
  	var decode = function(html, options) {
  		options = merge(options, decode.options);
  		var strict = options.strict;
  		if (strict && regexInvalidEntity.test(html)) {
  			parseError('malformed character reference');
  		}
  		return html.replace(regexDecode, function($0, $1, $2, $3, $4, $5, $6, $7, $8) {
  			var codePoint;
  			var semicolon;
  			var decDigits;
  			var hexDigits;
  			var reference;
  			var next;
  
  			if ($1) {
  				reference = $1;
  				// Note: there is no need to check `has(decodeMap, reference)`.
  				return decodeMap[reference];
  			}
  
  			if ($2) {
  				// Decode named character references without trailing `;`, e.g. `&amp`.
  				// This is only a parse error if it gets converted to `&`, or if it is
  				// followed by `=` in an attribute context.
  				reference = $2;
  				next = $3;
  				if (next && options.isAttributeValue) {
  					if (strict && next == '=') {
  						parseError('`&` did not start a character reference');
  					}
  					return $0;
  				} else {
  					if (strict) {
  						parseError(
  							'named character reference was not terminated by a semicolon'
  						);
  					}
  					// Note: there is no need to check `has(decodeMapLegacy, reference)`.
  					return decodeMapLegacy[reference] + (next || '');
  				}
  			}
  
  			if ($4) {
  				// Decode decimal escapes, e.g. `&#119558;`.
  				decDigits = $4;
  				semicolon = $5;
  				if (strict && !semicolon) {
  					parseError('character reference was not terminated by a semicolon');
  				}
  				codePoint = parseInt(decDigits, 10);
  				return codePointToSymbol(codePoint, strict);
  			}
  
  			if ($6) {
  				// Decode hexadecimal escapes, e.g. `&#x1D306;`.
  				hexDigits = $6;
  				semicolon = $7;
  				if (strict && !semicolon) {
  					parseError('character reference was not terminated by a semicolon');
  				}
  				codePoint = parseInt(hexDigits, 16);
  				return codePointToSymbol(codePoint, strict);
  			}
  
  			// If we’re still here, `if ($7)` is implied; it’s an ambiguous
  			// ampersand for sure. https://mths.be/notes/ambiguous-ampersands
  			if (strict) {
  				parseError(
  					'named character reference was not terminated by a semicolon'
  				);
  			}
  			return $0;
  		});
  	};
  	// Expose default options (so they can be overridden globally).
  	decode.options = {
  		'isAttributeValue': false,
  		'strict': false
  	};
  
  	var escape = function(string) {
  		return string.replace(regexEscape, function($0) {
  			// Note: there is no need to check `has(escapeMap, $0)` here.
  			return escapeMap[$0];
  		});
  	};
  
  	/*--------------------------------------------------------------------------*/
  
  	var he = {
  		'version': '1.2.0',
  		'encode': encode,
  		'decode': decode,
  		'escape': escape,
  		'unescape': decode
  	};
  
  	// Some AMD build optimizers, like r.js, check for specific condition patterns
  	// like the following:
  	if (
  		typeof define == 'function' &&
  		typeof define.amd == 'object' &&
  		define.amd
  	) {
  		define(function() {
  			return he;
  		});
  	}	else if (freeExports && !freeExports.nodeType) {
  		if (freeModule) { // in Node.js, io.js, or RingoJS v0.8.0+
  			freeModule.exports = he;
  		} else { // in Narwhal or RingoJS v0.7.0-
  			for (var key in he) {
  				has(he, key) && (freeExports[key] = he[key]);
  			}
  		}
  	} else { // in Rhino or a web browser
  		root.he = he;
  	}
  
  }(this));
  
  
  /***/ }),
  
  /***/ 8278:
  /***/ ((module) => {
  
  function toArray(arrayLikeObj) {
    if (!arrayLikeObj) return [];
  
    return Array.prototype.slice.call(arrayLikeObj);
  }
  
  function extend(destObject) {
    var args = toArray(arguments);
    var dest;
  
    if (args.length == 1) {
      return destObject;
    }
  
    args.shift();
  
    // 从前往后遍历
    for (var i = 0, l = args.length; i < l; i++) {
      for (var key in args[i]) {
        if (args[i].hasOwnProperty(key)) {
          destObject[key] = args[i][key];
        }
      }
    }
  
    return destObject;
  }
  
  function isTypeOf(something, type) {
    if (!type) return false;
  
    type = type.toLowerCase();
  
    var realTypeString = Object.prototype.toString.call(something);
  
    return realTypeString.toLowerCase() === '[object ' + type + ']';
  }
  
  function isArray(something) {
    return isTypeOf(something, 'array');
  }
  
  function isFunction(something) {
    return typeof something === 'function';
  }
  
  function isString(something) {
    return typeof something === 'string';
  }
  
  function isDefined(something) {
    return !(typeof something === 'undefined');
  }
  
  function isObject(something) {
    return typeof something === 'object';
  }
  
  function isReg(something) {
    return isTypeOf(something, 'regexp');
  }
  
  /**
   *
   * @param {Function/String/RegExp} rule
   * @param {String}                 entryName
   * @return {Boolean}
   */
  function isThisWhatYouNeed(rule, entryName) {
    return isFunction(rule) ? rule(entryName) :
      isString(rule) ? entryName.toLowerCase().indexOf(rule.toLowerCase()) > -1 :
        isReg(rule) ? rule.test(entryName.toLowerCase()) :
          false;
  }
  
  /**
   *
   * @param str
   * @param prefix
   * @returns {boolean}
   */
  function startWith(str, prefix) {
    return str.indexOf(prefix) === 0;
  }
  
  function isResouces(attrValue) {
    return startWith(attrValue, 'resourceId:');
  }
  
  function transKeyToMatchResourceMap(resourceId) {
    return '@' + resourceId.replace('resourceId:0x', '').toUpperCase();
  }
  
  function castLogger(doWhat, fromWhen) {
    console.log(doWhat + ' cost: ' + (Date.now() - fromWhen) + 'ms');
  }
  
  module.exports = {
    toArray: toArray,
    extend: extend,
    startWith: startWith,
    isResouces: isResouces,
    transKeyToMatchResourceMap: transKeyToMatchResourceMap,
    castLogger: castLogger,
    isTypeOf: isTypeOf,
    isArray: isArray,
    isFunction: isFunction,
    isString: isString,
    isDefined: isDefined,
    isObject: isObject,
    isReg: isReg,
    isThisWhatYouNeed: isThisWhatYouNeed
  };
  
  
  /***/ }),
  
  /***/ 7444:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  var yauzl = __nccwpck_require__(9119);
  var utils = __nccwpck_require__(8278);
  
  function Unzip(destPath) {
    if (!(this instanceof Unzip)) return new Unzip(path);
    this.path = destPath;
  }
  
  Unzip.prototype.destroy = function () {
    this.path = null;
  };
  
  /**
   * Iterator all entries,
   *
   * @param callback
   * @param onEnd
   */
  Unzip.prototype.getEntries = function (callback, onEnd) {
    yauzl.open(this.path, { lazyEntries: true }, function (err, zipfile) {
      if (err) {
        callback(err);
        return;
      }
  
      function next() {
        zipfile.readEntry();
      }
  
      zipfile.on('entry', function (entry) {
        callback(null, zipfile, entry, next);
      });
  
      zipfile.on('end', function () {
        if (utils.isFunction(onEnd)) {
          onEnd();
        }
      });
  
      next();
    });
  };
  
  /**
   *
   * @param {Array<String>} whatYouNeed
   * @param {Object}        options       In node, we don't support any options now.
   * @param callback Will be called like callback(err, buffers)
   * 
   * @param options.multiple {boolean} if this param is true, getBuffer will return all the file which match the whatYouNeed reg in an array, each item would be an Object with two props, fileName and buffer
   */
  Unzip.prototype.getBuffer = function (whatYouNeed, options, callback) {
    var finishedNumber = 0;
    const output = {};
    var entryCount = 0;
    var isMutiple = options && options.multiple || false;
    var currentIndex = 0;
  
    if (utils.isFunction(options)) {
      callback = options;
    }
  
    whatYouNeed = whatYouNeed.map(function (rule) {
      if (typeof rule === 'string') {
        rule = rule.split('\u0000').join('');
      }
      return rule;
    });
  
    this.getEntries(function (error, zipfile, entry, next) {
      if (error) return callback(error);
      entryCount = zipfile.entryCount;
      currentIndex++;
      var findIt = whatYouNeed.some(function (rule) {
        if (utils.isThisWhatYouNeed(rule, entry.fileName)) {
          Unzip.getEntryData(zipfile, entry, function (error, buffer) {
            if (error) {
              callback(error);
              return;
            }
  
            if (isMutiple) {
              var obj = {
                fileName: entry.fileName,
                buffer: buffer
              };
              if (output[rule]) {
                output[rule].push(obj);
              } else {
                output[rule] = [obj];
                finishedNumber++;
              }
            } else {
              output[rule] = buffer;
              finishedNumber++;
            }
  
            if (finishedNumber >= whatYouNeed.length && !isMutiple) {
              callback(null, output, entryCount);
            } else {
              next();
            }
          });
          return true;
        }
      });
  
      if (!findIt) next();
  
    }, function () {
      if ((finishedNumber < whatYouNeed.length) || (isMutiple && currentIndex >= entryCount)) {
        callback(null, output, entryCount);
      }
    });
  };
  
  Unzip.getEntryData = function (zipfile, entry, callback) {
    const bufferArr = [];
    zipfile.openReadStream(entry, function (err, readStream) {
      if (err) {
        callback(err);
        readStream.destroy();
        return;
      }
  
      readStream.on('data', function (chunk) {
        bufferArr.push(chunk);
      });
  
      readStream.on('end', function () {
        const buffer = Buffer.concat(bufferArr);
        callback(null, buffer);
      });
    });
  };
  
  module.exports = Unzip;
  
  
  /***/ }),
  
  /***/ 8478:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  /* module decorator */ module = __nccwpck_require__.nmd(module);
  /*
   Copyright 2013 Daniel Wirtz <dcode@dcode.io>
   Copyright 2009 The Closure Library Authors. All Rights Reserved.
  
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
  
   http://www.apache.org/licenses/LICENSE-2.0
  
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS-IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
   */
  
  /**
   * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
   * Released under the Apache License, Version 2.0
   * see: https://github.com/dcodeIO/long.js for details
   */
  (function(global, factory) {
  
      /* AMD */ if (typeof define === 'function' && define["amd"])
          define([], factory);
      /* CommonJS */ else if ( true && module && module["exports"])
          module["exports"] = factory();
      /* Global */ else
          (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();
  
  })(this, function() {
      "use strict";
  
      /**
       * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.
       *  See the from* functions below for more convenient ways of constructing Longs.
       * @exports Long
       * @class A Long class for representing a 64 bit two's-complement integer value.
       * @param {number} low The low (signed) 32 bits of the long
       * @param {number} high The high (signed) 32 bits of the long
       * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
       * @constructor
       */
      function Long(low, high, unsigned) {
  
          /**
           * The low 32 bits as a signed value.
           * @type {number}
           */
          this.low = low | 0;
  
          /**
           * The high 32 bits as a signed value.
           * @type {number}
           */
          this.high = high | 0;
  
          /**
           * Whether unsigned or not.
           * @type {boolean}
           */
          this.unsigned = !!unsigned;
      }
  
      // The internal representation of a long is the two given signed, 32-bit values.
      // We use 32-bit pieces because these are the size of integers on which
      // Javascript performs bit-operations.  For operations like addition and
      // multiplication, we split each number into 16 bit pieces, which can easily be
      // multiplied within Javascript's floating-point representation without overflow
      // or change in sign.
      //
      // In the algorithms below, we frequently reduce the negative case to the
      // positive case by negating the input(s) and then post-processing the result.
      // Note that we must ALWAYS check specially whether those values are MIN_VALUE
      // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
      // a positive number, it overflows back into a negative).  Not handling this
      // case would often result in infinite recursion.
      //
      // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*
      // methods on which they depend.
  
      /**
       * An indicator used to reliably determine if an object is a Long or not.
       * @type {boolean}
       * @const
       * @private
       */
      Long.prototype.__isLong__;
  
      Object.defineProperty(Long.prototype, "__isLong__", {
          value: true,
          enumerable: false,
          configurable: false
      });
  
      /**
       * @function
       * @param {*} obj Object
       * @returns {boolean}
       * @inner
       */
      function isLong(obj) {
          return (obj && obj["__isLong__"]) === true;
      }
  
      /**
       * Tests if the specified object is a Long.
       * @function
       * @param {*} obj Object
       * @returns {boolean}
       */
      Long.isLong = isLong;
  
      /**
       * A cache of the Long representations of small integer values.
       * @type {!Object}
       * @inner
       */
      var INT_CACHE = {};
  
      /**
       * A cache of the Long representations of small unsigned integer values.
       * @type {!Object}
       * @inner
       */
      var UINT_CACHE = {};
  
      /**
       * @param {number} value
       * @param {boolean=} unsigned
       * @returns {!Long}
       * @inner
       */
      function fromInt(value, unsigned) {
          var obj, cachedObj, cache;
          if (unsigned) {
              value >>>= 0;
              if (cache = (0 <= value && value < 256)) {
                  cachedObj = UINT_CACHE[value];
                  if (cachedObj)
                      return cachedObj;
              }
              obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);
              if (cache)
                  UINT_CACHE[value] = obj;
              return obj;
          } else {
              value |= 0;
              if (cache = (-128 <= value && value < 128)) {
                  cachedObj = INT_CACHE[value];
                  if (cachedObj)
                      return cachedObj;
              }
              obj = fromBits(value, value < 0 ? -1 : 0, false);
              if (cache)
                  INT_CACHE[value] = obj;
              return obj;
          }
      }
  
      /**
       * Returns a Long representing the given 32 bit integer value.
       * @function
       * @param {number} value The 32 bit integer in question
       * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
       * @returns {!Long} The corresponding Long value
       */
      Long.fromInt = fromInt;
  
      /**
       * @param {number} value
       * @param {boolean=} unsigned
       * @returns {!Long}
       * @inner
       */
      function fromNumber(value, unsigned) {
          if (isNaN(value) || !isFinite(value))
              return unsigned ? UZERO : ZERO;
          if (unsigned) {
              if (value < 0)
                  return UZERO;
              if (value >= TWO_PWR_64_DBL)
                  return MAX_UNSIGNED_VALUE;
          } else {
              if (value <= -TWO_PWR_63_DBL)
                  return MIN_VALUE;
              if (value + 1 >= TWO_PWR_63_DBL)
                  return MAX_VALUE;
          }
          if (value < 0)
              return fromNumber(-value, unsigned).neg();
          return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);
      }
  
      /**
       * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
       * @function
       * @param {number} value The number in question
       * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
       * @returns {!Long} The corresponding Long value
       */
      Long.fromNumber = fromNumber;
  
      /**
       * @param {number} lowBits
       * @param {number} highBits
       * @param {boolean=} unsigned
       * @returns {!Long}
       * @inner
       */
      function fromBits(lowBits, highBits, unsigned) {
          return new Long(lowBits, highBits, unsigned);
      }
  
      /**
       * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
       *  assumed to use 32 bits.
       * @function
       * @param {number} lowBits The low 32 bits
       * @param {number} highBits The high 32 bits
       * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
       * @returns {!Long} The corresponding Long value
       */
      Long.fromBits = fromBits;
  
      /**
       * @function
       * @param {number} base
       * @param {number} exponent
       * @returns {number}
       * @inner
       */
      var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)
  
      /**
       * @param {string} str
       * @param {(boolean|number)=} unsigned
       * @param {number=} radix
       * @returns {!Long}
       * @inner
       */
      function fromString(str, unsigned, radix) {
          if (str.length === 0)
              throw Error('empty string');
          if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
              return ZERO;
          if (typeof unsigned === 'number') {
              // For goog.math.long compatibility
              radix = unsigned,
              unsigned = false;
          } else {
              unsigned = !! unsigned;
          }
          radix = radix || 10;
          if (radix < 2 || 36 < radix)
              throw RangeError('radix');
  
          var p;
          if ((p = str.indexOf('-')) > 0)
              throw Error('interior hyphen');
          else if (p === 0) {
              return fromString(str.substring(1), unsigned, radix).neg();
          }
  
          // Do several (8) digits each time through the loop, so as to
          // minimize the calls to the very expensive emulated div.
          var radixToPower = fromNumber(pow_dbl(radix, 8));
  
          var result = ZERO;
          for (var i = 0; i < str.length; i += 8) {
              var size = Math.min(8, str.length - i),
                  value = parseInt(str.substring(i, i + size), radix);
              if (size < 8) {
                  var power = fromNumber(pow_dbl(radix, size));
                  result = result.mul(power).add(fromNumber(value));
              } else {
                  result = result.mul(radixToPower);
                  result = result.add(fromNumber(value));
              }
          }
          result.unsigned = unsigned;
          return result;
      }
  
      /**
       * Returns a Long representation of the given string, written using the specified radix.
       * @function
       * @param {string} str The textual representation of the Long
       * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed
       * @param {number=} radix The radix in which the text is written (2-36), defaults to 10
       * @returns {!Long} The corresponding Long value
       */
      Long.fromString = fromString;
  
      /**
       * @function
       * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val
       * @returns {!Long}
       * @inner
       */
      function fromValue(val) {
          if (val /* is compatible */ instanceof Long)
              return val;
          if (typeof val === 'number')
              return fromNumber(val);
          if (typeof val === 'string')
              return fromString(val);
          // Throws for non-objects, converts non-instanceof Long:
          return fromBits(val.low, val.high, val.unsigned);
      }
  
      /**
       * Converts the specified value to a Long.
       * @function
       * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value
       * @returns {!Long}
       */
      Long.fromValue = fromValue;
  
      // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be
      // no runtime penalty for these.
  
      /**
       * @type {number}
       * @const
       * @inner
       */
      var TWO_PWR_16_DBL = 1 << 16;
  
      /**
       * @type {number}
       * @const
       * @inner
       */
      var TWO_PWR_24_DBL = 1 << 24;
  
      /**
       * @type {number}
       * @const
       * @inner
       */
      var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
  
      /**
       * @type {number}
       * @const
       * @inner
       */
      var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
  
      /**
       * @type {number}
       * @const
       * @inner
       */
      var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
  
      /**
       * @type {!Long}
       * @const
       * @inner
       */
      var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
  
      /**
       * @type {!Long}
       * @inner
       */
      var ZERO = fromInt(0);
  
      /**
       * Signed zero.
       * @type {!Long}
       */
      Long.ZERO = ZERO;
  
      /**
       * @type {!Long}
       * @inner
       */
      var UZERO = fromInt(0, true);
  
      /**
       * Unsigned zero.
       * @type {!Long}
       */
      Long.UZERO = UZERO;
  
      /**
       * @type {!Long}
       * @inner
       */
      var ONE = fromInt(1);
  
      /**
       * Signed one.
       * @type {!Long}
       */
      Long.ONE = ONE;
  
      /**
       * @type {!Long}
       * @inner
       */
      var UONE = fromInt(1, true);
  
      /**
       * Unsigned one.
       * @type {!Long}
       */
      Long.UONE = UONE;
  
      /**
       * @type {!Long}
       * @inner
       */
      var NEG_ONE = fromInt(-1);
  
      /**
       * Signed negative one.
       * @type {!Long}
       */
      Long.NEG_ONE = NEG_ONE;
  
      /**
       * @type {!Long}
       * @inner
       */
      var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);
  
      /**
       * Maximum signed value.
       * @type {!Long}
       */
      Long.MAX_VALUE = MAX_VALUE;
  
      /**
       * @type {!Long}
       * @inner
       */
      var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);
  
      /**
       * Maximum unsigned value.
       * @type {!Long}
       */
      Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
  
      /**
       * @type {!Long}
       * @inner
       */
      var MIN_VALUE = fromBits(0, 0x80000000|0, false);
  
      /**
       * Minimum signed value.
       * @type {!Long}
       */
      Long.MIN_VALUE = MIN_VALUE;
  
      /**
       * @alias Long.prototype
       * @inner
       */
      var LongPrototype = Long.prototype;
  
      /**
       * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
       * @returns {number}
       */
      LongPrototype.toInt = function toInt() {
          return this.unsigned ? this.low >>> 0 : this.low;
      };
  
      /**
       * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
       * @returns {number}
       */
      LongPrototype.toNumber = function toNumber() {
          if (this.unsigned)
              return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);
          return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
      };
  
      /**
       * Converts the Long to a string written in the specified radix.
       * @param {number=} radix Radix (2-36), defaults to 10
       * @returns {string}
       * @override
       * @throws {RangeError} If `radix` is out of range
       */
      LongPrototype.toString = function toString(radix) {
          radix = radix || 10;
          if (radix < 2 || 36 < radix)
              throw RangeError('radix');
          if (this.isZero())
              return '0';
          if (this.isNegative()) { // Unsigned Longs are never negative
              if (this.eq(MIN_VALUE)) {
                  // We need to change the Long value before it can be negated, so we remove
                  // the bottom-most digit in this base and then recurse to do the rest.
                  var radixLong = fromNumber(radix),
                      div = this.div(radixLong),
                      rem1 = div.mul(radixLong).sub(this);
                  return div.toString(radix) + rem1.toInt().toString(radix);
              } else
                  return '-' + this.neg().toString(radix);
          }
  
          // Do several (6) digits each time through the loop, so as to
          // minimize the calls to the very expensive emulated div.
          var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
              rem = this;
          var result = '';
          while (true) {
              var remDiv = rem.div(radixToPower),
                  intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,
                  digits = intval.toString(radix);
              rem = remDiv;
              if (rem.isZero())
                  return digits + result;
              else {
                  while (digits.length < 6)
                      digits = '0' + digits;
                  result = '' + digits + result;
              }
          }
      };
  
      /**
       * Gets the high 32 bits as a signed integer.
       * @returns {number} Signed high bits
       */
      LongPrototype.getHighBits = function getHighBits() {
          return this.high;
      };
  
      /**
       * Gets the high 32 bits as an unsigned integer.
       * @returns {number} Unsigned high bits
       */
      LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
          return this.high >>> 0;
      };
  
      /**
       * Gets the low 32 bits as a signed integer.
       * @returns {number} Signed low bits
       */
      LongPrototype.getLowBits = function getLowBits() {
          return this.low;
      };
  
      /**
       * Gets the low 32 bits as an unsigned integer.
       * @returns {number} Unsigned low bits
       */
      LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
          return this.low >>> 0;
      };
  
      /**
       * Gets the number of bits needed to represent the absolute value of this Long.
       * @returns {number}
       */
      LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
          if (this.isNegative()) // Unsigned Longs are never negative
              return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
          var val = this.high != 0 ? this.high : this.low;
          for (var bit = 31; bit > 0; bit--)
              if ((val & (1 << bit)) != 0)
                  break;
          return this.high != 0 ? bit + 33 : bit + 1;
      };
  
      /**
       * Tests if this Long's value equals zero.
       * @returns {boolean}
       */
      LongPrototype.isZero = function isZero() {
          return this.high === 0 && this.low === 0;
      };
  
      /**
       * Tests if this Long's value is negative.
       * @returns {boolean}
       */
      LongPrototype.isNegative = function isNegative() {
          return !this.unsigned && this.high < 0;
      };
  
      /**
       * Tests if this Long's value is positive.
       * @returns {boolean}
       */
      LongPrototype.isPositive = function isPositive() {
          return this.unsigned || this.high >= 0;
      };
  
      /**
       * Tests if this Long's value is odd.
       * @returns {boolean}
       */
      LongPrototype.isOdd = function isOdd() {
          return (this.low & 1) === 1;
      };
  
      /**
       * Tests if this Long's value is even.
       * @returns {boolean}
       */
      LongPrototype.isEven = function isEven() {
          return (this.low & 1) === 0;
      };
  
      /**
       * Tests if this Long's value equals the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.equals = function equals(other) {
          if (!isLong(other))
              other = fromValue(other);
          if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)
              return false;
          return this.high === other.high && this.low === other.low;
      };
  
      /**
       * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.eq = LongPrototype.equals;
  
      /**
       * Tests if this Long's value differs from the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.notEquals = function notEquals(other) {
          return !this.eq(/* validates */ other);
      };
  
      /**
       * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.neq = LongPrototype.notEquals;
  
      /**
       * Tests if this Long's value is less than the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.lessThan = function lessThan(other) {
          return this.comp(/* validates */ other) < 0;
      };
  
      /**
       * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.lt = LongPrototype.lessThan;
  
      /**
       * Tests if this Long's value is less than or equal the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
          return this.comp(/* validates */ other) <= 0;
      };
  
      /**
       * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.lte = LongPrototype.lessThanOrEqual;
  
      /**
       * Tests if this Long's value is greater than the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.greaterThan = function greaterThan(other) {
          return this.comp(/* validates */ other) > 0;
      };
  
      /**
       * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.gt = LongPrototype.greaterThan;
  
      /**
       * Tests if this Long's value is greater than or equal the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
          return this.comp(/* validates */ other) >= 0;
      };
  
      /**
       * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {boolean}
       */
      LongPrototype.gte = LongPrototype.greaterThanOrEqual;
  
      /**
       * Compares this Long's value with the specified's.
       * @param {!Long|number|string} other Other value
       * @returns {number} 0 if they are the same, 1 if the this is greater and -1
       *  if the given one is greater
       */
      LongPrototype.compare = function compare(other) {
          if (!isLong(other))
              other = fromValue(other);
          if (this.eq(other))
              return 0;
          var thisNeg = this.isNegative(),
              otherNeg = other.isNegative();
          if (thisNeg && !otherNeg)
              return -1;
          if (!thisNeg && otherNeg)
              return 1;
          // At this point the sign bits are the same
          if (!this.unsigned)
              return this.sub(other).isNegative() ? -1 : 1;
          // Both are positive if at least one is unsigned
          return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;
      };
  
      /**
       * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.
       * @function
       * @param {!Long|number|string} other Other value
       * @returns {number} 0 if they are the same, 1 if the this is greater and -1
       *  if the given one is greater
       */
      LongPrototype.comp = LongPrototype.compare;
  
      /**
       * Negates this Long's value.
       * @returns {!Long} Negated Long
       */
      LongPrototype.negate = function negate() {
          if (!this.unsigned && this.eq(MIN_VALUE))
              return MIN_VALUE;
          return this.not().add(ONE);
      };
  
      /**
       * Negates this Long's value. This is an alias of {@link Long#negate}.
       * @function
       * @returns {!Long} Negated Long
       */
      LongPrototype.neg = LongPrototype.negate;
  
      /**
       * Returns the sum of this and the specified Long.
       * @param {!Long|number|string} addend Addend
       * @returns {!Long} Sum
       */
      LongPrototype.add = function add(addend) {
          if (!isLong(addend))
              addend = fromValue(addend);
  
          // Divide each number into 4 chunks of 16 bits, and then sum the chunks.
  
          var a48 = this.high >>> 16;
          var a32 = this.high & 0xFFFF;
          var a16 = this.low >>> 16;
          var a00 = this.low & 0xFFFF;
  
          var b48 = addend.high >>> 16;
          var b32 = addend.high & 0xFFFF;
          var b16 = addend.low >>> 16;
          var b00 = addend.low & 0xFFFF;
  
          var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
          c00 += a00 + b00;
          c16 += c00 >>> 16;
          c00 &= 0xFFFF;
          c16 += a16 + b16;
          c32 += c16 >>> 16;
          c16 &= 0xFFFF;
          c32 += a32 + b32;
          c48 += c32 >>> 16;
          c32 &= 0xFFFF;
          c48 += a48 + b48;
          c48 &= 0xFFFF;
          return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
      };
  
      /**
       * Returns the difference of this and the specified Long.
       * @param {!Long|number|string} subtrahend Subtrahend
       * @returns {!Long} Difference
       */
      LongPrototype.subtract = function subtract(subtrahend) {
          if (!isLong(subtrahend))
              subtrahend = fromValue(subtrahend);
          return this.add(subtrahend.neg());
      };
  
      /**
       * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.
       * @function
       * @param {!Long|number|string} subtrahend Subtrahend
       * @returns {!Long} Difference
       */
      LongPrototype.sub = LongPrototype.subtract;
  
      /**
       * Returns the product of this and the specified Long.
       * @param {!Long|number|string} multiplier Multiplier
       * @returns {!Long} Product
       */
      LongPrototype.multiply = function multiply(multiplier) {
          if (this.isZero())
              return ZERO;
          if (!isLong(multiplier))
              multiplier = fromValue(multiplier);
          if (multiplier.isZero())
              return ZERO;
          if (this.eq(MIN_VALUE))
              return multiplier.isOdd() ? MIN_VALUE : ZERO;
          if (multiplier.eq(MIN_VALUE))
              return this.isOdd() ? MIN_VALUE : ZERO;
  
          if (this.isNegative()) {
              if (multiplier.isNegative())
                  return this.neg().mul(multiplier.neg());
              else
                  return this.neg().mul(multiplier).neg();
          } else if (multiplier.isNegative())
              return this.mul(multiplier.neg()).neg();
  
          // If both longs are small, use float multiplication
          if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
              return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);
  
          // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
          // We can skip products that would overflow.
  
          var a48 = this.high >>> 16;
          var a32 = this.high & 0xFFFF;
          var a16 = this.low >>> 16;
          var a00 = this.low & 0xFFFF;
  
          var b48 = multiplier.high >>> 16;
          var b32 = multiplier.high & 0xFFFF;
          var b16 = multiplier.low >>> 16;
          var b00 = multiplier.low & 0xFFFF;
  
          var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
          c00 += a00 * b00;
          c16 += c00 >>> 16;
          c00 &= 0xFFFF;
          c16 += a16 * b00;
          c32 += c16 >>> 16;
          c16 &= 0xFFFF;
          c16 += a00 * b16;
          c32 += c16 >>> 16;
          c16 &= 0xFFFF;
          c32 += a32 * b00;
          c48 += c32 >>> 16;
          c32 &= 0xFFFF;
          c32 += a16 * b16;
          c48 += c32 >>> 16;
          c32 &= 0xFFFF;
          c32 += a00 * b32;
          c48 += c32 >>> 16;
          c32 &= 0xFFFF;
          c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
          c48 &= 0xFFFF;
          return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);
      };
  
      /**
       * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.
       * @function
       * @param {!Long|number|string} multiplier Multiplier
       * @returns {!Long} Product
       */
      LongPrototype.mul = LongPrototype.multiply;
  
      /**
       * Returns this Long divided by the specified. The result is signed if this Long is signed or
       *  unsigned if this Long is unsigned.
       * @param {!Long|number|string} divisor Divisor
       * @returns {!Long} Quotient
       */
      LongPrototype.divide = function divide(divisor) {
          if (!isLong(divisor))
              divisor = fromValue(divisor);
          if (divisor.isZero())
              throw Error('division by zero');
          if (this.isZero())
              return this.unsigned ? UZERO : ZERO;
          var approx, rem, res;
          if (!this.unsigned) {
              // This section is only relevant for signed longs and is derived from the
              // closure library as a whole.
              if (this.eq(MIN_VALUE)) {
                  if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
                      return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE
                  else if (divisor.eq(MIN_VALUE))
                      return ONE;
                  else {
                      // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
                      var halfThis = this.shr(1);
                      approx = halfThis.div(divisor).shl(1);
                      if (approx.eq(ZERO)) {
                          return divisor.isNegative() ? ONE : NEG_ONE;
                      } else {
                          rem = this.sub(divisor.mul(approx));
                          res = approx.add(rem.div(divisor));
                          return res;
                      }
                  }
              } else if (divisor.eq(MIN_VALUE))
                  return this.unsigned ? UZERO : ZERO;
              if (this.isNegative()) {
                  if (divisor.isNegative())
                      return this.neg().div(divisor.neg());
                  return this.neg().div(divisor).neg();
              } else if (divisor.isNegative())
                  return this.div(divisor.neg()).neg();
              res = ZERO;
          } else {
              // The algorithm below has not been made for unsigned longs. It's therefore
              // required to take special care of the MSB prior to running it.
              if (!divisor.unsigned)
                  divisor = divisor.toUnsigned();
              if (divisor.gt(this))
                  return UZERO;
              if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true
                  return UONE;
              res = UZERO;
          }
  
          // Repeat the following until the remainder is less than other:  find a
          // floating-point that approximates remainder / other *from below*, add this
          // into the result, and subtract it from the remainder.  It is critical that
          // the approximate value is less than or equal to the real value so that the
          // remainder never becomes negative.
          rem = this;
          while (rem.gte(divisor)) {
              // Approximate the result of division. This may be a little greater or
              // smaller than the actual value.
              approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
  
              // We will tweak the approximate result by changing it in the 48-th digit or
              // the smallest non-fractional digit, whichever is larger.
              var log2 = Math.ceil(Math.log(approx) / Math.LN2),
                  delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),
  
              // Decrease the approximation until it is smaller than the remainder.  Note
              // that if it is too large, the product overflows and is negative.
                  approxRes = fromNumber(approx),
                  approxRem = approxRes.mul(divisor);
              while (approxRem.isNegative() || approxRem.gt(rem)) {
                  approx -= delta;
                  approxRes = fromNumber(approx, this.unsigned);
                  approxRem = approxRes.mul(divisor);
              }
  
              // We know the answer can't be zero... and actually, zero would cause
              // infinite recursion since we would make no progress.
              if (approxRes.isZero())
                  approxRes = ONE;
  
              res = res.add(approxRes);
              rem = rem.sub(approxRem);
          }
          return res;
      };
  
      /**
       * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.
       * @function
       * @param {!Long|number|string} divisor Divisor
       * @returns {!Long} Quotient
       */
      LongPrototype.div = LongPrototype.divide;
  
      /**
       * Returns this Long modulo the specified.
       * @param {!Long|number|string} divisor Divisor
       * @returns {!Long} Remainder
       */
      LongPrototype.modulo = function modulo(divisor) {
          if (!isLong(divisor))
              divisor = fromValue(divisor);
          return this.sub(this.div(divisor).mul(divisor));
      };
  
      /**
       * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
       * @function
       * @param {!Long|number|string} divisor Divisor
       * @returns {!Long} Remainder
       */
      LongPrototype.mod = LongPrototype.modulo;
  
      /**
       * Returns the bitwise NOT of this Long.
       * @returns {!Long}
       */
      LongPrototype.not = function not() {
          return fromBits(~this.low, ~this.high, this.unsigned);
      };
  
      /**
       * Returns the bitwise AND of this Long and the specified.
       * @param {!Long|number|string} other Other Long
       * @returns {!Long}
       */
      LongPrototype.and = function and(other) {
          if (!isLong(other))
              other = fromValue(other);
          return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
      };
  
      /**
       * Returns the bitwise OR of this Long and the specified.
       * @param {!Long|number|string} other Other Long
       * @returns {!Long}
       */
      LongPrototype.or = function or(other) {
          if (!isLong(other))
              other = fromValue(other);
          return fromBits(this.low | other.low, this.high | other.high, this.unsigned);
      };
  
      /**
       * Returns the bitwise XOR of this Long and the given one.
       * @param {!Long|number|string} other Other Long
       * @returns {!Long}
       */
      LongPrototype.xor = function xor(other) {
          if (!isLong(other))
              other = fromValue(other);
          return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
      };
  
      /**
       * Returns this Long with bits shifted to the left by the given amount.
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shiftLeft = function shiftLeft(numBits) {
          if (isLong(numBits))
              numBits = numBits.toInt();
          if ((numBits &= 63) === 0)
              return this;
          else if (numBits < 32)
              return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);
          else
              return fromBits(0, this.low << (numBits - 32), this.unsigned);
      };
  
      /**
       * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.
       * @function
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shl = LongPrototype.shiftLeft;
  
      /**
       * Returns this Long with bits arithmetically shifted to the right by the given amount.
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shiftRight = function shiftRight(numBits) {
          if (isLong(numBits))
              numBits = numBits.toInt();
          if ((numBits &= 63) === 0)
              return this;
          else if (numBits < 32)
              return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);
          else
              return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);
      };
  
      /**
       * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.
       * @function
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shr = LongPrototype.shiftRight;
  
      /**
       * Returns this Long with bits logically shifted to the right by the given amount.
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
          if (isLong(numBits))
              numBits = numBits.toInt();
          numBits &= 63;
          if (numBits === 0)
              return this;
          else {
              var high = this.high;
              if (numBits < 32) {
                  var low = this.low;
                  return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);
              } else if (numBits === 32)
                  return fromBits(high, 0, this.unsigned);
              else
                  return fromBits(high >>> (numBits - 32), 0, this.unsigned);
          }
      };
  
      /**
       * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
       * @function
       * @param {number|!Long} numBits Number of bits
       * @returns {!Long} Shifted Long
       */
      LongPrototype.shru = LongPrototype.shiftRightUnsigned;
  
      /**
       * Converts this Long to signed.
       * @returns {!Long} Signed long
       */
      LongPrototype.toSigned = function toSigned() {
          if (!this.unsigned)
              return this;
          return fromBits(this.low, this.high, false);
      };
  
      /**
       * Converts this Long to unsigned.
       * @returns {!Long} Unsigned long
       */
      LongPrototype.toUnsigned = function toUnsigned() {
          if (this.unsigned)
              return this;
          return fromBits(this.low, this.high, true);
      };
  
      /**
       * Converts this Long to its byte representation.
       * @param {boolean=} le Whether little or big endian, defaults to big endian
       * @returns {!Array.<number>} Byte representation
       */
      LongPrototype.toBytes = function(le) {
          return le ? this.toBytesLE() : this.toBytesBE();
      }
  
      /**
       * Converts this Long to its little endian byte representation.
       * @returns {!Array.<number>} Little endian byte representation
       */
      LongPrototype.toBytesLE = function() {
          var hi = this.high,
              lo = this.low;
          return [
               lo         & 0xff,
              (lo >>>  8) & 0xff,
              (lo >>> 16) & 0xff,
              (lo >>> 24) & 0xff,
               hi         & 0xff,
              (hi >>>  8) & 0xff,
              (hi >>> 16) & 0xff,
              (hi >>> 24) & 0xff
          ];
      }
  
      /**
       * Converts this Long to its big endian byte representation.
       * @returns {!Array.<number>} Big endian byte representation
       */
      LongPrototype.toBytesBE = function() {
          var hi = this.high,
              lo = this.low;
          return [
              (hi >>> 24) & 0xff,
              (hi >>> 16) & 0xff,
              (hi >>>  8) & 0xff,
               hi         & 0xff,
              (lo >>> 24) & 0xff,
              (lo >>> 16) & 0xff,
              (lo >>>  8) & 0xff,
               lo         & 0xff
          ];
      }
  
      return Long;
  });
  
  
  /***/ }),
  
  /***/ 9326:
  /***/ ((module) => {
  
  module.exports = Pend;
  
  function Pend() {
    this.pending = 0;
    this.max = Infinity;
    this.listeners = [];
    this.waiting = [];
    this.error = null;
  }
  
  Pend.prototype.go = function(fn) {
    if (this.pending < this.max) {
      pendGo(this, fn);
    } else {
      this.waiting.push(fn);
    }
  };
  
  Pend.prototype.wait = function(cb) {
    if (this.pending === 0) {
      cb(this.error);
    } else {
      this.listeners.push(cb);
    }
  };
  
  Pend.prototype.hold = function() {
    return pendHold(this);
  };
  
  function pendHold(self) {
    self.pending += 1;
    var called = false;
    return onCb;
    function onCb(err) {
      if (called) throw new Error("callback called twice");
      called = true;
      self.error = self.error || err;
      self.pending -= 1;
      if (self.waiting.length > 0 && self.pending < self.max) {
        pendGo(self, self.waiting.shift());
      } else if (self.pending === 0) {
        var listeners = self.listeners;
        self.listeners = [];
        listeners.forEach(cbListener);
      }
    }
    function cbListener(listener) {
      listener(self.error);
    }
  }
  
  function pendGo(self, fn) {
    fn(pendHold(self));
  }
  
  
  /***/ }),
  
  /***/ 272:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Parser functions.
   */
  
  var parserFunctions = __nccwpck_require__(8822);
  Object.keys(parserFunctions).forEach(function (k) { exports[k] = parserFunctions[k]; });
  
  /**
   * Builder functions.
   */
  
  var builderFunctions = __nccwpck_require__(3620);
  Object.keys(builderFunctions).forEach(function (k) { exports[k] = builderFunctions[k]; });
  
  
  /***/ }),
  
  /***/ 3620:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Module dependencies.
   */
  
  var base64 = __nccwpck_require__(2023);
  var xmlbuilder = __nccwpck_require__(6966);
  
  /**
   * Module exports.
   */
  
  exports.build = build;
  
  /**
   * Accepts a `Date` instance and returns an ISO date string.
   *
   * @param {Date} d - Date instance to serialize
   * @returns {String} ISO date string representation of `d`
   * @api private
   */
  
  function ISODateString(d){
    function pad(n){
      return n < 10 ? '0' + n : n;
    }
    return d.getUTCFullYear()+'-'
      + pad(d.getUTCMonth()+1)+'-'
      + pad(d.getUTCDate())+'T'
      + pad(d.getUTCHours())+':'
      + pad(d.getUTCMinutes())+':'
      + pad(d.getUTCSeconds())+'Z';
  }
  
  /**
   * Returns the internal "type" of `obj` via the
   * `Object.prototype.toString()` trick.
   *
   * @param {Mixed} obj - any value
   * @returns {String} the internal "type" name
   * @api private
   */
  
  var toString = Object.prototype.toString;
  function type (obj) {
    var m = toString.call(obj).match(/\[object (.*)\]/);
    return m ? m[1] : m;
  }
  
  /**
   * Generate an XML plist string from the input object `obj`.
   *
   * @param {Object} obj - the object to convert
   * @param {Object} [opts] - optional options object
   * @returns {String} converted plist XML string
   * @api public
   */
  
  function build (obj, opts) {
    var XMLHDR = {
      version: '1.0',
      encoding: 'UTF-8'
    };
  
    var XMLDTD = {
      pubid: '-//Apple//DTD PLIST 1.0//EN',
      sysid: 'http://www.apple.com/DTDs/PropertyList-1.0.dtd'
    };
  
    var doc = xmlbuilder.create('plist');
  
    doc.dec(XMLHDR.version, XMLHDR.encoding, XMLHDR.standalone);
    doc.dtd(XMLDTD.pubid, XMLDTD.sysid);
    doc.att('version', '1.0');
  
    walk_obj(obj, doc);
  
    if (!opts) opts = {};
    // default `pretty` to `true`
    opts.pretty = opts.pretty !== false;
    return doc.end(opts);
  }
  
  /**
   * depth first, recursive traversal of a javascript object. when complete,
   * next_child contains a reference to the build XML object.
   *
   * @api private
   */
  
  function walk_obj(next, next_child) {
    var tag_type, i, prop;
    var name = type(next);
  
    if ('Undefined' == name) {
      return;
    } else if (Array.isArray(next)) {
      next_child = next_child.ele('array');
      for (i = 0; i < next.length; i++) {
        walk_obj(next[i], next_child);
      }
  
    } else if (Buffer.isBuffer(next)) {
      next_child.ele('data').raw(next.toString('base64'));
  
    } else if ('Object' == name) {
      next_child = next_child.ele('dict');
      for (prop in next) {
        if (next.hasOwnProperty(prop)) {
          next_child.ele('key').txt(prop);
          walk_obj(next[prop], next_child);
        }
      }
  
    } else if ('Number' == name) {
      // detect if this is an integer or real
      // TODO: add an ability to force one way or another via a "cast"
      tag_type = (next % 1 === 0) ? 'integer' : 'real';
      next_child.ele(tag_type).txt(next.toString());
  
    } else if ('Date' == name) {
      next_child.ele('date').txt(ISODateString(new Date(next)));
  
    } else if ('Boolean' == name) {
      next_child.ele(next ? 'true' : 'false');
  
    } else if ('String' == name) {
      next_child.ele('string').txt(next);
  
    } else if ('ArrayBuffer' == name) {
      next_child.ele('data').raw(base64.fromByteArray(next));
  
    } else if (next && next.buffer && 'ArrayBuffer' == type(next.buffer)) {
      // a typed array
      next_child.ele('data').raw(base64.fromByteArray(new Uint8Array(next.buffer), next_child));
  
    }
  }
  
  
  /***/ }),
  
  /***/ 8822:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  /**
   * Module dependencies.
   */
  
  var DOMParser = __nccwpck_require__(558)/* .DOMParser */ .a;
  
  /**
   * Module exports.
   */
  
  exports.parse = parse;
  
  var TEXT_NODE = 3;
  var CDATA_NODE = 4;
  var COMMENT_NODE = 8;
  
  
  /**
   * We ignore raw text (usually whitespace), <!-- xml comments -->,
   * and raw CDATA nodes.
   *
   * @param {Element} node
   * @returns {Boolean}
   * @api private
   */
  
  function shouldIgnoreNode (node) {
    return node.nodeType === TEXT_NODE
      || node.nodeType === COMMENT_NODE
      || node.nodeType === CDATA_NODE;
  }
  
  /**
   * Check if the node is empty. Some plist file has such node:
   * <key />
   * this node shoud be ignored.
   *
   * @see https://github.com/TooTallNate/plist.js/issues/66
   * @param {Element} node
   * @returns {Boolean}
   * @api private
   */
  function isEmptyNode(node){
    if(!node.childNodes || node.childNodes.length === 0) {
      return true;
    } else {
      return false;
    }
  }
  
  function invariant(test, message) {
    if (!test) {
      throw new Error(message);
    }
  }
  
  /**
   * Parses a Plist XML string. Returns an Object.
   *
   * @param {String} xml - the XML String to decode
   * @returns {Mixed} the decoded value from the Plist XML
   * @api public
   */
  
  function parse (xml) {
    var doc = new DOMParser().parseFromString(xml);
    invariant(
      doc.documentElement.nodeName === 'plist',
      'malformed document. First element should be <plist>'
    );
    var plist = parsePlistXML(doc.documentElement);
  
    // the root <plist> node gets interpreted as an Array,
    // so pull out the inner data first
    if (plist.length == 1) plist = plist[0];
  
    return plist;
  }
  
  /**
   * Convert an XML based plist document into a JSON representation.
   *
   * @param {Object} xml_node - current XML node in the plist
   * @returns {Mixed} built up JSON object
   * @api private
   */
  
  function parsePlistXML (node) {
    var i, new_obj, key, val, new_arr, res, counter, type;
  
    if (!node)
      return null;
  
    if (node.nodeName === 'plist') {
      new_arr = [];
      if (isEmptyNode(node)) {
        return new_arr;
      }
      for (i=0; i < node.childNodes.length; i++) {
        if (!shouldIgnoreNode(node.childNodes[i])) {
          new_arr.push( parsePlistXML(node.childNodes[i]));
        }
      }
      return new_arr;
    } else if (node.nodeName === 'dict') {
      new_obj = {};
      key = null;
      counter = 0;
      if (isEmptyNode(node)) {
        return new_obj;
      }
      for (i=0; i < node.childNodes.length; i++) {
        if (shouldIgnoreNode(node.childNodes[i])) continue;
        if (counter % 2 === 0) {
          invariant(
            node.childNodes[i].nodeName === 'key',
            'Missing key while parsing <dict/>.'
          );
          key = parsePlistXML(node.childNodes[i]);
        } else {
          invariant(
            node.childNodes[i].nodeName !== 'key',
            'Unexpected key "'
              + parsePlistXML(node.childNodes[i])
              + '" while parsing <dict/>.'
          );
          new_obj[key] = parsePlistXML(node.childNodes[i]);
        }
        counter += 1;
      }
      if (counter % 2 === 1) {
        throw new Error('Missing value for "' + key + '" while parsing <dict/>');
      }
      return new_obj;
  
    } else if (node.nodeName === 'array') {
      new_arr = [];
      if (isEmptyNode(node)) {
        return new_arr;
      }
      for (i=0; i < node.childNodes.length; i++) {
        if (!shouldIgnoreNode(node.childNodes[i])) {
          res = parsePlistXML(node.childNodes[i]);
          if (null != res) new_arr.push(res);
        }
      }
      return new_arr;
  
    } else if (node.nodeName === '#text') {
      // TODO: what should we do with text types? (CDATA sections)
  
    } else if (node.nodeName === 'key') {
      if (isEmptyNode(node)) {
        return '';
      }
      return node.childNodes[0].nodeValue;
    } else if (node.nodeName === 'string') {
      res = '';
      if (isEmptyNode(node)) {
        return res;
      }
      for (i=0; i < node.childNodes.length; i++) {
        var type = node.childNodes[i].nodeType;
        if (type === TEXT_NODE || type === CDATA_NODE) {
          res += node.childNodes[i].nodeValue;
        }
      }
      return res;
  
    } else if (node.nodeName === 'integer') {
      invariant(
        !isEmptyNode(node),
        'Cannot parse "" as integer.'
      );
      return parseInt(node.childNodes[0].nodeValue, 10);
  
    } else if (node.nodeName === 'real') {
      invariant(
        !isEmptyNode(node),
        'Cannot parse "" as real.'
      );
      res = '';
      for (i=0; i < node.childNodes.length; i++) {
        if (node.childNodes[i].nodeType === TEXT_NODE) {
          res += node.childNodes[i].nodeValue;
        }
      }
      return parseFloat(res);
  
    } else if (node.nodeName === 'data') {
      res = '';
      if (isEmptyNode(node)) {
        return Buffer.from(res, 'base64');
      }
      for (i=0; i < node.childNodes.length; i++) {
        if (node.childNodes[i].nodeType === TEXT_NODE) {
          res += node.childNodes[i].nodeValue.replace(/\s+/g, '');
        }
      }
      return Buffer.from(res, 'base64');
  
    } else if (node.nodeName === 'date') {
      invariant(
        !isEmptyNode(node),
        'Cannot parse "" as Date.'
      )
      return new Date(node.childNodes[0].nodeValue);
  
    } else if (node.nodeName === 'true') {
      return true;
  
    } else if (node.nodeName === 'false') {
      return false;
    }
  }
  
  
  /***/ }),
  
  /***/ 9956:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  module.exports = __nccwpck_require__(6691).buffer
  
  /***/ }),
  
  /***/ 6691:
  /***/ ((__unused_webpack_module, exports) => {
  
  var __webpack_unused_export__;
  __webpack_unused_export__ = toArray
  exports.buffer = toBuffer
  
  function toArray(stream, callback) {
    var arr = []
  
    stream.on('data', onData)
    stream.once('end', onEnd)
    stream.once('error', callback)
    stream.once('error', cleanup)
    stream.once('close', cleanup)
  
    function onData(doc) {
      arr.push(doc)
    }
  
    function onEnd() {
      callback(null, arr)
      cleanup()
    }
  
    function cleanup() {
      arr = null
      stream.removeListener('data', onData)
      stream.removeListener('end', onEnd)
      stream.removeListener('error', callback)
      stream.removeListener('error', cleanup)
      stream.removeListener('close', cleanup)
    }
  
    return stream
  }
  
  function toBuffer(stream, callback) {
    toArray(stream, function (err, arr) {
      if (err || !arr)
        callback(err)
      else
        callback(null, Buffer.concat(arr))
    })
  
    return stream
  }
  
  /***/ }),
  
  /***/ 2504:
  /***/ ((module, __unused_webpack_exports, __nccwpck_require__) => {
  
  "use strict";
  
  
  var util = __nccwpck_require__(1669);
  var stream = __nccwpck_require__(2413);
  
  module.exports.createReadStream = function (object, options) {
    return new MultiStream (object, options);
  };
  
  var MultiStream = function (object, options) {
    if (object instanceof Buffer || typeof object === 'string') {
      options = options || {};
      stream.Readable.call(this, {
        highWaterMark: options.highWaterMark,
        encoding: options.encoding
      });
    } else {
      stream.Readable.call(this, { objectMode: true });
    }
    this._object = object;
  };
  
  util.inherits(MultiStream, stream.Readable);
  
  MultiStream.prototype._read = function () {
    this.push(this._object);
    this._object = null;
  };
  
  /***/ }),
  
  /***/ 1968:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var assign, 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));
    };
  
    module.exports.assign = assign;
  
    module.exports.isFunction = isFunction;
  
    module.exports.isObject = isObject;
  
    module.exports.isArray = isArray;
  
    module.exports.isEmpty = isEmpty;
  
    module.exports.isPlainObject = isPlainObject;
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9485:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLAttribute;
  
    module.exports = XMLAttribute = (function() {
      function XMLAttribute(parent, name, value) {
        this.options = parent.options;
        this.stringify = parent.stringify;
        if (name == null) {
          throw new Error("Missing attribute name of element " + parent.name);
        }
        if (value == null) {
          throw new Error("Missing attribute value for attribute " + name + " of element " + parent.name);
        }
        this.name = this.stringify.attName(name);
        this.value = this.stringify.attValue(value);
      }
  
      XMLAttribute.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLAttribute.prototype.toString = function(options) {
        return this.options.writer.set(options).attribute(this);
      };
  
      return XMLAttribute;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4812:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLCData, 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__(4736);
  
    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.text = this.stringify.cdata(text);
      }
  
      XMLCData.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLCData.prototype.toString = function(options) {
        return this.options.writer.set(options).cdata(this);
      };
  
      return XMLCData;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 5098:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLComment, 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__(4736);
  
    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.text = this.stringify.comment(text);
      }
  
      XMLComment.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLComment.prototype.toString = function(options) {
        return this.options.writer.set(options).comment(this);
      };
  
      return XMLComment;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6525:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(4736);
  
    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");
        }
        if (attributeName == null) {
          throw new Error("Missing DTD attribute name");
        }
        if (!attributeType) {
          throw new Error("Missing DTD attribute type");
        }
        if (!defaultValueType) {
          throw new Error("Missing DTD attribute default");
        }
        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");
        }
        if (defaultValue && !defaultValueType.match(/^(#FIXED|#DEFAULT)$/)) {
          throw new Error("Default value only applies to #FIXED or #DEFAULT");
        }
        this.elementName = this.stringify.eleName(elementName);
        this.attributeName = this.stringify.attName(attributeName);
        this.attributeType = this.stringify.dtdAttType(attributeType);
        this.defaultValue = this.stringify.dtdAttDefault(defaultValue);
        this.defaultValueType = defaultValueType;
      }
  
      XMLDTDAttList.prototype.toString = function(options) {
        return this.options.writer.set(options).dtdAttList(this);
      };
  
      return XMLDTDAttList;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 110:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(4736);
  
    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");
        }
        if (!value) {
          value = '(#PCDATA)';
        }
        if (Array.isArray(value)) {
          value = '(' + value.join(',') + ')';
        }
        this.name = this.stringify.eleName(name);
        this.value = this.stringify.dtdElementValue(value);
      }
  
      XMLDTDElement.prototype.toString = function(options) {
        return this.options.writer.set(options).dtdElement(this);
      };
  
      return XMLDTDElement;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 3678:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(1968).isObject;
  
    XMLNode = __nccwpck_require__(4736);
  
    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 entity name");
        }
        if (value == null) {
          throw new Error("Missing entity value");
        }
        this.pe = !!pe;
        this.name = this.stringify.eleName(name);
        if (!isObject(value)) {
          this.value = this.stringify.dtdEntityValue(value);
        } else {
          if (!value.pubID && !value.sysID) {
            throw new Error("Public and/or system identifiers are required for an external entity");
          }
          if (value.pubID && !value.sysID) {
            throw new Error("System identifier is required for a public external entity");
          }
          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");
          }
        }
      }
  
      XMLDTDEntity.prototype.toString = function(options) {
        return this.options.writer.set(options).dtdEntity(this);
      };
  
      return XMLDTDEntity;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9358:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(4736);
  
    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 notation name");
        }
        if (!value.pubID && !value.sysID) {
          throw new Error("Public or system identifiers are required for an external entity");
        }
        this.name = this.stringify.eleName(name);
        if (value.pubID != null) {
          this.pubID = this.stringify.dtdPubID(value.pubID);
        }
        if (value.sysID != null) {
          this.sysID = this.stringify.dtdSysID(value.sysID);
        }
      }
  
      XMLDTDNotation.prototype.toString = function(options) {
        return this.options.writer.set(options).dtdNotation(this);
      };
  
      return XMLDTDNotation;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 886:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(1968).isObject;
  
    XMLNode = __nccwpck_require__(4736);
  
    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.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.set(options).declaration(this);
      };
  
      return XMLDeclaration;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 608:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDocType, 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__(1968).isObject;
  
    XMLNode = __nccwpck_require__(4736);
  
    XMLDTDAttList = __nccwpck_require__(6525);
  
    XMLDTDEntity = __nccwpck_require__(3678);
  
    XMLDTDElement = __nccwpck_require__(110);
  
    XMLDTDNotation = __nccwpck_require__(9358);
  
    module.exports = XMLDocType = (function(superClass) {
      extend(XMLDocType, superClass);
  
      function XMLDocType(parent, pubID, sysID) {
        var ref, ref1;
        XMLDocType.__super__.constructor.call(this, parent);
        this.documentObject = parent;
        if (isObject(pubID)) {
          ref = pubID, pubID = ref.pubID, sysID = ref.sysID;
        }
        if (sysID == null) {
          ref1 = [pubID, sysID], sysID = ref1[0], pubID = ref1[1];
        }
        if (pubID != null) {
          this.pubID = this.stringify.dtdPubID(pubID);
        }
        if (sysID != null) {
          this.sysID = this.stringify.dtdSysID(sysID);
        }
      }
  
      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.set(options).docType(this);
      };
  
      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;
      };
  
      return XMLDocType;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 1139:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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__(1968).isPlainObject;
  
    XMLNode = __nccwpck_require__(4736);
  
    XMLStringifier = __nccwpck_require__(5338);
  
    XMLStringWriter = __nccwpck_require__(9024);
  
    module.exports = XMLDocument = (function(superClass) {
      extend(XMLDocument, superClass);
  
      function XMLDocument(options) {
        XMLDocument.__super__.constructor.call(this, null);
        options || (options = {});
        if (!options.writer) {
          options.writer = new XMLStringWriter();
        }
        this.options = options;
        this.stringify = new XMLStringifier(options);
        this.isDocument = true;
      }
  
      XMLDocument.prototype.end = function(writer) {
        var writerOptions;
        if (!writer) {
          writer = this.options.writer;
        } else if (isPlainObject(writer)) {
          writerOptions = writer;
          writer = this.options.writer.set(writerOptions);
        }
        return writer.document(this);
      };
  
      XMLDocument.prototype.toString = function(options) {
        return this.options.writer.set(options).document(this);
      };
  
      return XMLDocument;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4285:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLAttribute, XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLDocumentCB, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLStringifier, XMLText, isFunction, isObject, isPlainObject, ref,
      hasProp = {}.hasOwnProperty;
  
    ref = __nccwpck_require__(1968), isObject = ref.isObject, isFunction = ref.isFunction, isPlainObject = ref.isPlainObject;
  
    XMLElement = __nccwpck_require__(1428);
  
    XMLCData = __nccwpck_require__(4812);
  
    XMLComment = __nccwpck_require__(5098);
  
    XMLRaw = __nccwpck_require__(759);
  
    XMLText = __nccwpck_require__(7329);
  
    XMLProcessingInstruction = __nccwpck_require__(574);
  
    XMLDeclaration = __nccwpck_require__(886);
  
    XMLDocType = __nccwpck_require__(608);
  
    XMLDTDAttList = __nccwpck_require__(6525);
  
    XMLDTDEntity = __nccwpck_require__(3678);
  
    XMLDTDElement = __nccwpck_require__(110);
  
    XMLDTDNotation = __nccwpck_require__(9358);
  
    XMLAttribute = __nccwpck_require__(9485);
  
    XMLStringifier = __nccwpck_require__(5338);
  
    XMLStringWriter = __nccwpck_require__(9024);
  
    module.exports = XMLDocumentCB = (function() {
      function XMLDocumentCB(options, onData, onEnd) {
        var writerOptions;
        options || (options = {});
        if (!options.writer) {
          options.writer = new XMLStringWriter(options);
        } else if (isPlainObject(options.writer)) {
          writerOptions = options.writer;
          options.writer = new XMLStringWriter(writerOptions);
        }
        this.options = options;
        this.writer = options.writer;
        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.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.openCurrent();
        name = name.valueOf();
        if (attributes == null) {
          attributes = {};
        }
        attributes = attributes.valueOf();
        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) {
        if (this.currentNode && this.currentNode instanceof XMLDocType) {
          return this.dtdElement.apply(this, arguments);
        } else {
          return this.node(name, attributes, text);
        }
      };
  
      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");
        }
        if (name != null) {
          name = name.valueOf();
        }
        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.skipNullAttributes || (value != null)) {
            this.currentNode.attributes[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.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.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.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.currentLevel + 1));
        return this;
      };
  
      XMLDocumentCB.prototype.instruction = function(target, value) {
        var i, insTarget, insValue, len, node;
        this.openCurrent();
        if (target != null) {
          target = target.valueOf();
        }
        if (value != null) {
          value = value.valueOf();
        }
        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.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.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.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.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.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.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.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) {
        if (!node.isOpen) {
          if (!this.root && this.currentLevel === 0 && node instanceof XMLElement) {
            this.root = node;
          }
          this.onData(this.writer.openNode(node, this.currentLevel));
          return node.isOpen = true;
        }
      };
  
      XMLDocumentCB.prototype.closeNode = function(node) {
        if (!node.isClosed) {
          this.onData(this.writer.closeNode(node, this.currentLevel));
          return node.isClosed = true;
        }
      };
  
      XMLDocumentCB.prototype.onData = function(chunk) {
        this.documentStarted = true;
        return this.onDataCallback(chunk);
      };
  
      XMLDocumentCB.prototype.onEnd = function() {
        this.documentCompleted = true;
        return this.onEndCallback();
      };
  
      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 instanceof XMLDocType) {
          return this.attList.apply(this, arguments);
        } else {
          return this.attribute.apply(this, arguments);
        }
      };
  
      XMLDocumentCB.prototype.a = function() {
        if (this.currentNode && this.currentNode instanceof XMLDocType) {
          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);
  
  
  /***/ }),
  
  /***/ 1428:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLAttribute, XMLElement, XMLNode, 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__(1968), isObject = ref.isObject, isFunction = ref.isFunction;
  
    XMLNode = __nccwpck_require__(4736);
  
    XMLAttribute = __nccwpck_require__(9485);
  
    module.exports = XMLElement = (function(superClass) {
      extend(XMLElement, superClass);
  
      function XMLElement(parent, name, attributes) {
        XMLElement.__super__.constructor.call(this, parent);
        if (name == null) {
          throw new Error("Missing element name");
        }
        this.name = this.stringify.eleName(name);
        this.attributes = {};
        if (attributes != null) {
          this.attribute(attributes);
        }
        if (parent.isDocument) {
          this.isRoot = true;
          this.documentObject = parent;
          parent.rootObject = this;
        }
      }
  
      XMLElement.prototype.clone = function() {
        var att, attName, clonedSelf, ref1;
        clonedSelf = Object.create(this);
        if (clonedSelf.isRoot) {
          clonedSelf.documentObject = null;
        }
        clonedSelf.attributes = {};
        ref1 = this.attributes;
        for (attName in ref1) {
          if (!hasProp.call(ref1, attName)) continue;
          att = ref1[attName];
          clonedSelf.attributes[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 = name.valueOf();
        }
        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.skipNullAttributes || (value != null)) {
            this.attributes[name] = new XMLAttribute(this, name, value);
          }
        }
        return this;
      };
  
      XMLElement.prototype.removeAttribute = function(name) {
        var attName, i, len;
        if (name == null) {
          throw new Error("Missing attribute name");
        }
        name = name.valueOf();
        if (Array.isArray(name)) {
          for (i = 0, len = name.length; i < len; i++) {
            attName = name[i];
            delete this.attributes[attName];
          }
        } else {
          delete this.attributes[name];
        }
        return this;
      };
  
      XMLElement.prototype.toString = function(options) {
        return this.options.writer.set(options).element(this);
      };
  
      XMLElement.prototype.att = function(name, value) {
        return this.attribute(name, value);
      };
  
      XMLElement.prototype.a = function(name, value) {
        return this.attribute(name, value);
      };
  
      return XMLElement;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4736:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLCData, XMLComment, XMLDeclaration, XMLDocType, XMLElement, XMLNode, XMLProcessingInstruction, XMLRaw, XMLText, isEmpty, isFunction, isObject, ref,
      hasProp = {}.hasOwnProperty;
  
    ref = __nccwpck_require__(1968), isObject = ref.isObject, isFunction = ref.isFunction, isEmpty = ref.isEmpty;
  
    XMLElement = null;
  
    XMLCData = null;
  
    XMLComment = null;
  
    XMLDeclaration = null;
  
    XMLDocType = null;
  
    XMLRaw = null;
  
    XMLText = null;
  
    XMLProcessingInstruction = null;
  
    module.exports = XMLNode = (function() {
      function XMLNode(parent) {
        this.parent = parent;
        if (this.parent) {
          this.options = this.parent.options;
          this.stringify = this.parent.stringify;
        }
        this.children = [];
        if (!XMLElement) {
          XMLElement = __nccwpck_require__(1428);
          XMLCData = __nccwpck_require__(4812);
          XMLComment = __nccwpck_require__(5098);
          XMLDeclaration = __nccwpck_require__(886);
          XMLDocType = __nccwpck_require__(608);
          XMLRaw = __nccwpck_require__(759);
          XMLText = __nccwpck_require__(7329);
          XMLProcessingInstruction = __nccwpck_require__(574);
        }
      }
  
      XMLNode.prototype.element = function(name, attributes, text) {
        var childNode, item, j, k, key, lastChild, len, len1, ref1, val;
        lastChild = null;
        if (attributes == null) {
          attributes = {};
        }
        attributes = attributes.valueOf();
        if (!isObject(attributes)) {
          ref1 = [attributes, text], text = ref1[0], attributes = ref1[1];
        }
        if (name != null) {
          name = name.valueOf();
        }
        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 ((isObject(val)) && (isEmpty(val))) {
              val = null;
            }
            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)) {
              for (k = 0, len1 = val.length; k < len1; k++) {
                item = val[k];
                childNode = {};
                childNode[key] = item;
                lastChild = this.element(childNode);
              }
            } else if (isObject(val)) {
              lastChild = this.element(key);
              lastChild.element(val);
            } else {
              lastChild = this.element(key, val);
            }
          }
        } 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);
        }
        return lastChild;
      };
  
      XMLNode.prototype.insertBefore = function(name, attributes, text) {
        var child, i, removed;
        if (this.isRoot) {
          throw new Error("Cannot insert elements at root level");
        }
        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");
        }
        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, ref1;
        if (this.isRoot) {
          throw new Error("Cannot remove the root element");
        }
        i = this.parent.children.indexOf(this);
        [].splice.apply(this.parent.children, [i, i - i + 1].concat(ref1 = [])), ref1;
        return this.parent;
      };
  
      XMLNode.prototype.node = function(name, attributes, text) {
        var child, ref1;
        if (name != null) {
          name = name.valueOf();
        }
        attributes || (attributes = {});
        attributes = attributes.valueOf();
        if (!isObject(attributes)) {
          ref1 = [attributes, text], text = ref1[0], attributes = ref1[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;
        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.instruction = function(target, value) {
        var insTarget, insValue, instruction, j, len;
        if (target != null) {
          target = target.valueOf();
        }
        if (value != null) {
          value = value.valueOf();
        }
        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[0] instanceof XMLDeclaration) {
          doc.children[0] = xmldec;
        } else {
          doc.children.unshift(xmldec);
        }
        return doc.root() || doc;
      };
  
      XMLNode.prototype.doctype = function(pubID, sysID) {
        var child, doc, doctype, i, j, k, len, len1, ref1, ref2;
        doc = this.document();
        doctype = new XMLDocType(doc, pubID, sysID);
        ref1 = doc.children;
        for (i = j = 0, len = ref1.length; j < len; i = ++j) {
          child = ref1[i];
          if (child instanceof XMLDocType) {
            doc.children[i] = doctype;
            return doctype;
          }
        }
        ref2 = doc.children;
        for (i = k = 0, len1 = ref2.length; k < len1; i = ++k) {
          child = ref2[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.isDocument) {
            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.isDocument) {
            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");
        }
        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");
        }
        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.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.dtd = function(pubID, sysID) {
        return this.doctype(pubID, sysID);
      };
  
      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);
      };
  
      return XMLNode;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 574:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLNode, 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;
  
    XMLNode = __nccwpck_require__(4736);
  
    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.target = this.stringify.insTarget(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.set(options).processingInstruction(this);
      };
  
      return XMLProcessingInstruction;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 759:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var 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;
  
    XMLNode = __nccwpck_require__(4736);
  
    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.value = this.stringify.raw(text);
      }
  
      XMLRaw.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLRaw.prototype.toString = function(options) {
        return this.options.writer.set(options).raw(this);
      };
  
      return XMLRaw;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 4088:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStreamWriter, XMLText, 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;
  
    XMLDeclaration = __nccwpck_require__(886);
  
    XMLDocType = __nccwpck_require__(608);
  
    XMLCData = __nccwpck_require__(4812);
  
    XMLComment = __nccwpck_require__(5098);
  
    XMLElement = __nccwpck_require__(1428);
  
    XMLRaw = __nccwpck_require__(759);
  
    XMLText = __nccwpck_require__(7329);
  
    XMLProcessingInstruction = __nccwpck_require__(574);
  
    XMLDTDAttList = __nccwpck_require__(6525);
  
    XMLDTDElement = __nccwpck_require__(110);
  
    XMLDTDEntity = __nccwpck_require__(3678);
  
    XMLDTDNotation = __nccwpck_require__(9358);
  
    XMLWriterBase = __nccwpck_require__(7846);
  
    module.exports = XMLStreamWriter = (function(superClass) {
      extend(XMLStreamWriter, superClass);
  
      function XMLStreamWriter(stream, options) {
        XMLStreamWriter.__super__.constructor.call(this, options);
        this.stream = stream;
      }
  
      XMLStreamWriter.prototype.document = function(doc) {
        var child, i, j, len, len1, ref, ref1, results;
        ref = doc.children;
        for (i = 0, len = ref.length; i < len; i++) {
          child = ref[i];
          child.isLastRootNode = false;
        }
        doc.children[doc.children.length - 1].isLastRootNode = true;
        ref1 = doc.children;
        results = [];
        for (j = 0, len1 = ref1.length; j < len1; j++) {
          child = ref1[j];
          switch (false) {
            case !(child instanceof XMLDeclaration):
              results.push(this.declaration(child));
              break;
            case !(child instanceof XMLDocType):
              results.push(this.docType(child));
              break;
            case !(child instanceof XMLComment):
              results.push(this.comment(child));
              break;
            case !(child instanceof XMLProcessingInstruction):
              results.push(this.processingInstruction(child));
              break;
            default:
              results.push(this.element(child));
          }
        }
        return results;
      };
  
      XMLStreamWriter.prototype.attribute = function(att) {
        return this.stream.write(' ' + att.name + '="' + att.value + '"');
      };
  
      XMLStreamWriter.prototype.cdata = function(node, level) {
        return this.stream.write(this.space(level) + '<![CDATA[' + node.text + ']]>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.comment = function(node, level) {
        return this.stream.write(this.space(level) + '<!-- ' + node.text + ' -->' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.declaration = function(node, level) {
        this.stream.write(this.space(level));
        this.stream.write('<?xml version="' + node.version + '"');
        if (node.encoding != null) {
          this.stream.write(' encoding="' + node.encoding + '"');
        }
        if (node.standalone != null) {
          this.stream.write(' standalone="' + node.standalone + '"');
        }
        this.stream.write(this.spacebeforeslash + '?>');
        return this.stream.write(this.endline(node));
      };
  
      XMLStreamWriter.prototype.docType = function(node, level) {
        var child, i, len, ref;
        level || (level = 0);
        this.stream.write(this.space(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));
          ref = node.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            switch (false) {
              case !(child instanceof XMLDTDAttList):
                this.dtdAttList(child, level + 1);
                break;
              case !(child instanceof XMLDTDElement):
                this.dtdElement(child, level + 1);
                break;
              case !(child instanceof XMLDTDEntity):
                this.dtdEntity(child, level + 1);
                break;
              case !(child instanceof XMLDTDNotation):
                this.dtdNotation(child, level + 1);
                break;
              case !(child instanceof XMLCData):
                this.cdata(child, level + 1);
                break;
              case !(child instanceof XMLComment):
                this.comment(child, level + 1);
                break;
              case !(child instanceof XMLProcessingInstruction):
                this.processingInstruction(child, level + 1);
                break;
              default:
                throw new Error("Unknown DTD node type: " + child.constructor.name);
            }
          }
          this.stream.write(']');
        }
        this.stream.write(this.spacebeforeslash + '>');
        return this.stream.write(this.endline(node));
      };
  
      XMLStreamWriter.prototype.element = function(node, level) {
        var att, child, i, len, name, ref, ref1, space;
        level || (level = 0);
        space = this.space(level);
        this.stream.write(space + '<' + node.name);
        ref = node.attributes;
        for (name in ref) {
          if (!hasProp.call(ref, name)) continue;
          att = ref[name];
          this.attribute(att);
        }
        if (node.children.length === 0 || node.children.every(function(e) {
          return e.value === '';
        })) {
          if (this.allowEmpty) {
            this.stream.write('></' + node.name + '>');
          } else {
            this.stream.write(this.spacebeforeslash + '/>');
          }
        } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
          this.stream.write('>');
          this.stream.write(node.children[0].value);
          this.stream.write('</' + node.name + '>');
        } else {
          this.stream.write('>' + this.newline);
          ref1 = node.children;
          for (i = 0, len = ref1.length; i < len; i++) {
            child = ref1[i];
            switch (false) {
              case !(child instanceof XMLCData):
                this.cdata(child, level + 1);
                break;
              case !(child instanceof XMLComment):
                this.comment(child, level + 1);
                break;
              case !(child instanceof XMLElement):
                this.element(child, level + 1);
                break;
              case !(child instanceof XMLRaw):
                this.raw(child, level + 1);
                break;
              case !(child instanceof XMLText):
                this.text(child, level + 1);
                break;
              case !(child instanceof XMLProcessingInstruction):
                this.processingInstruction(child, level + 1);
                break;
              default:
                throw new Error("Unknown XML node type: " + child.constructor.name);
            }
          }
          this.stream.write(space + '</' + node.name + '>');
        }
        return this.stream.write(this.endline(node));
      };
  
      XMLStreamWriter.prototype.processingInstruction = function(node, level) {
        this.stream.write(this.space(level) + '<?' + node.target);
        if (node.value) {
          this.stream.write(' ' + node.value);
        }
        return this.stream.write(this.spacebeforeslash + '?>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.raw = function(node, level) {
        return this.stream.write(this.space(level) + node.value + this.endline(node));
      };
  
      XMLStreamWriter.prototype.text = function(node, level) {
        return this.stream.write(this.space(level) + node.value + this.endline(node));
      };
  
      XMLStreamWriter.prototype.dtdAttList = function(node, level) {
        this.stream.write(this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType);
        if (node.defaultValueType !== '#DEFAULT') {
          this.stream.write(' ' + node.defaultValueType);
        }
        if (node.defaultValue) {
          this.stream.write(' "' + node.defaultValue + '"');
        }
        return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.dtdElement = function(node, level) {
        this.stream.write(this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value);
        return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.dtdEntity = function(node, level) {
        this.stream.write(this.space(level) + '<!ENTITY');
        if (node.pe) {
          this.stream.write(' %');
        }
        this.stream.write(' ' + node.name);
        if (node.value) {
          this.stream.write(' "' + node.value + '"');
        } else {
          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.nData) {
            this.stream.write(' NDATA ' + node.nData);
          }
        }
        return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.dtdNotation = function(node, level) {
        this.stream.write(this.space(level) + '<!NOTATION ' + node.name);
        if (node.pubID && node.sysID) {
          this.stream.write(' PUBLIC "' + node.pubID + '" "' + node.sysID + '"');
        } else if (node.pubID) {
          this.stream.write(' PUBLIC "' + node.pubID + '"');
        } else if (node.sysID) {
          this.stream.write(' SYSTEM "' + node.sysID + '"');
        }
        return this.stream.write(this.spacebeforeslash + '>' + this.endline(node));
      };
  
      XMLStreamWriter.prototype.endline = function(node) {
        if (!node.isLastRootNode) {
          return this.newline;
        } else {
          return '';
        }
      };
  
      return XMLStreamWriter;
  
    })(XMLWriterBase);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 9024:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLCData, XMLComment, XMLDTDAttList, XMLDTDElement, XMLDTDEntity, XMLDTDNotation, XMLDeclaration, XMLDocType, XMLElement, XMLProcessingInstruction, XMLRaw, XMLStringWriter, XMLText, 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;
  
    XMLDeclaration = __nccwpck_require__(886);
  
    XMLDocType = __nccwpck_require__(608);
  
    XMLCData = __nccwpck_require__(4812);
  
    XMLComment = __nccwpck_require__(5098);
  
    XMLElement = __nccwpck_require__(1428);
  
    XMLRaw = __nccwpck_require__(759);
  
    XMLText = __nccwpck_require__(7329);
  
    XMLProcessingInstruction = __nccwpck_require__(574);
  
    XMLDTDAttList = __nccwpck_require__(6525);
  
    XMLDTDElement = __nccwpck_require__(110);
  
    XMLDTDEntity = __nccwpck_require__(3678);
  
    XMLDTDNotation = __nccwpck_require__(9358);
  
    XMLWriterBase = __nccwpck_require__(7846);
  
    module.exports = XMLStringWriter = (function(superClass) {
      extend(XMLStringWriter, superClass);
  
      function XMLStringWriter(options) {
        XMLStringWriter.__super__.constructor.call(this, options);
      }
  
      XMLStringWriter.prototype.document = function(doc) {
        var child, i, len, r, ref;
        this.textispresent = false;
        r = '';
        ref = doc.children;
        for (i = 0, len = ref.length; i < len; i++) {
          child = ref[i];
          r += (function() {
            switch (false) {
              case !(child instanceof XMLDeclaration):
                return this.declaration(child);
              case !(child instanceof XMLDocType):
                return this.docType(child);
              case !(child instanceof XMLComment):
                return this.comment(child);
              case !(child instanceof XMLProcessingInstruction):
                return this.processingInstruction(child);
              default:
                return this.element(child, 0);
            }
          }).call(this);
        }
        if (this.pretty && r.slice(-this.newline.length) === this.newline) {
          r = r.slice(0, -this.newline.length);
        }
        return r;
      };
  
      XMLStringWriter.prototype.attribute = function(att) {
        return ' ' + att.name + '="' + att.value + '"';
      };
  
      XMLStringWriter.prototype.cdata = function(node, level) {
        return this.space(level) + '<![CDATA[' + node.text + ']]>' + this.newline;
      };
  
      XMLStringWriter.prototype.comment = function(node, level) {
        return this.space(level) + '<!-- ' + node.text + ' -->' + this.newline;
      };
  
      XMLStringWriter.prototype.declaration = function(node, level) {
        var r;
        r = this.space(level);
        r += '<?xml version="' + node.version + '"';
        if (node.encoding != null) {
          r += ' encoding="' + node.encoding + '"';
        }
        if (node.standalone != null) {
          r += ' standalone="' + node.standalone + '"';
        }
        r += this.spacebeforeslash + '?>';
        r += this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.docType = function(node, level) {
        var child, i, len, r, ref;
        level || (level = 0);
        r = this.space(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.newline;
          ref = node.children;
          for (i = 0, len = ref.length; i < len; i++) {
            child = ref[i];
            r += (function() {
              switch (false) {
                case !(child instanceof XMLDTDAttList):
                  return this.dtdAttList(child, level + 1);
                case !(child instanceof XMLDTDElement):
                  return this.dtdElement(child, level + 1);
                case !(child instanceof XMLDTDEntity):
                  return this.dtdEntity(child, level + 1);
                case !(child instanceof XMLDTDNotation):
                  return this.dtdNotation(child, level + 1);
                case !(child instanceof XMLCData):
                  return this.cdata(child, level + 1);
                case !(child instanceof XMLComment):
                  return this.comment(child, level + 1);
                case !(child instanceof XMLProcessingInstruction):
                  return this.processingInstruction(child, level + 1);
                default:
                  throw new Error("Unknown DTD node type: " + child.constructor.name);
              }
            }).call(this);
          }
          r += ']';
        }
        r += this.spacebeforeslash + '>';
        r += this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.element = function(node, level) {
        var att, child, i, j, len, len1, name, r, ref, ref1, ref2, space, textispresentwasset;
        level || (level = 0);
        textispresentwasset = false;
        if (this.textispresent) {
          this.newline = '';
          this.pretty = false;
        } else {
          this.newline = this.newlinedefault;
          this.pretty = this.prettydefault;
        }
        space = this.space(level);
        r = '';
        r += space + '<' + node.name;
        ref = node.attributes;
        for (name in ref) {
          if (!hasProp.call(ref, name)) continue;
          att = ref[name];
          r += this.attribute(att);
        }
        if (node.children.length === 0 || node.children.every(function(e) {
          return e.value === '';
        })) {
          if (this.allowEmpty) {
            r += '></' + node.name + '>' + this.newline;
          } else {
            r += this.spacebeforeslash + '/>' + this.newline;
          }
        } else if (this.pretty && node.children.length === 1 && (node.children[0].value != null)) {
          r += '>';
          r += node.children[0].value;
          r += '</' + node.name + '>' + this.newline;
        } else {
          if (this.dontprettytextnodes) {
            ref1 = node.children;
            for (i = 0, len = ref1.length; i < len; i++) {
              child = ref1[i];
              if (child.value != null) {
                this.textispresent++;
                textispresentwasset = true;
                break;
              }
            }
          }
          if (this.textispresent) {
            this.newline = '';
            this.pretty = false;
            space = this.space(level);
          }
          r += '>' + this.newline;
          ref2 = node.children;
          for (j = 0, len1 = ref2.length; j < len1; j++) {
            child = ref2[j];
            r += (function() {
              switch (false) {
                case !(child instanceof XMLCData):
                  return this.cdata(child, level + 1);
                case !(child instanceof XMLComment):
                  return this.comment(child, level + 1);
                case !(child instanceof XMLElement):
                  return this.element(child, level + 1);
                case !(child instanceof XMLRaw):
                  return this.raw(child, level + 1);
                case !(child instanceof XMLText):
                  return this.text(child, level + 1);
                case !(child instanceof XMLProcessingInstruction):
                  return this.processingInstruction(child, level + 1);
                default:
                  throw new Error("Unknown XML node type: " + child.constructor.name);
              }
            }).call(this);
          }
          if (textispresentwasset) {
            this.textispresent--;
          }
          if (!this.textispresent) {
            this.newline = this.newlinedefault;
            this.pretty = this.prettydefault;
          }
          r += space + '</' + node.name + '>' + this.newline;
        }
        return r;
      };
  
      XMLStringWriter.prototype.processingInstruction = function(node, level) {
        var r;
        r = this.space(level) + '<?' + node.target;
        if (node.value) {
          r += ' ' + node.value;
        }
        r += this.spacebeforeslash + '?>' + this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.raw = function(node, level) {
        return this.space(level) + node.value + this.newline;
      };
  
      XMLStringWriter.prototype.text = function(node, level) {
        return this.space(level) + node.value + this.newline;
      };
  
      XMLStringWriter.prototype.dtdAttList = function(node, level) {
        var r;
        r = this.space(level) + '<!ATTLIST ' + node.elementName + ' ' + node.attributeName + ' ' + node.attributeType;
        if (node.defaultValueType !== '#DEFAULT') {
          r += ' ' + node.defaultValueType;
        }
        if (node.defaultValue) {
          r += ' "' + node.defaultValue + '"';
        }
        r += this.spacebeforeslash + '>' + this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.dtdElement = function(node, level) {
        return this.space(level) + '<!ELEMENT ' + node.name + ' ' + node.value + this.spacebeforeslash + '>' + this.newline;
      };
  
      XMLStringWriter.prototype.dtdEntity = function(node, level) {
        var r;
        r = this.space(level) + '<!ENTITY';
        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;
          }
        }
        r += this.spacebeforeslash + '>' + this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.dtdNotation = function(node, level) {
        var r;
        r = this.space(level) + '<!NOTATION ' + 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 + '"';
        }
        r += this.spacebeforeslash + '>' + this.newline;
        return r;
      };
  
      XMLStringWriter.prototype.openNode = function(node, level) {
        var att, name, r, ref;
        level || (level = 0);
        if (node instanceof XMLElement) {
          r = this.space(level) + '<' + node.name;
          ref = node.attributes;
          for (name in ref) {
            if (!hasProp.call(ref, name)) continue;
            att = ref[name];
            r += this.attribute(att);
          }
          r += (node.children ? '>' : '/>') + this.newline;
          return r;
        } else {
          r = this.space(level) + '<!DOCTYPE ' + node.rootNodeName;
          if (node.pubID && node.sysID) {
            r += ' PUBLIC "' + node.pubID + '" "' + node.sysID + '"';
          } else if (node.sysID) {
            r += ' SYSTEM "' + node.sysID + '"';
          }
          r += (node.children ? ' [' : '>') + this.newline;
          return r;
        }
      };
  
      XMLStringWriter.prototype.closeNode = function(node, level) {
        level || (level = 0);
        switch (false) {
          case !(node instanceof XMLElement):
            return this.space(level) + '</' + node.name + '>' + this.newline;
          case !(node instanceof XMLDocType):
            return this.space(level) + ']>' + this.newline;
        }
      };
  
      return XMLStringWriter;
  
    })(XMLWriterBase);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 5338:
  /***/ (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.assertLegalChar = bind(this.assertLegalChar, this);
        var key, ref, value;
        options || (options = {});
        this.noDoubleEncoding = options.noDoubleEncoding;
        ref = options.stringify || {};
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this[key] = value;
        }
      }
  
      XMLStringifier.prototype.eleName = function(val) {
        val = '' + val || '';
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.eleText = function(val) {
        val = '' + val || '';
        return this.assertLegalChar(this.elEscape(val));
      };
  
      XMLStringifier.prototype.cdata = function(val) {
        val = '' + val || '';
        val = val.replace(']]>', ']]]]><![CDATA[>');
        return this.assertLegalChar(val);
      };
  
      XMLStringifier.prototype.comment = function(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) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.attName = function(val) {
        return val = '' + val || '';
      };
  
      XMLStringifier.prototype.attValue = function(val) {
        val = '' + val || '';
        return this.attEscape(val);
      };
  
      XMLStringifier.prototype.insTarget = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.insValue = function(val) {
        val = '' + val || '';
        if (val.match(/\?>/)) {
          throw new Error("Invalid processing instruction value: " + val);
        }
        return val;
      };
  
      XMLStringifier.prototype.xmlVersion = function(val) {
        val = '' + val || '';
        if (!val.match(/1\.[0-9]+/)) {
          throw new Error("Invalid version number: " + val);
        }
        return val;
      };
  
      XMLStringifier.prototype.xmlEncoding = function(val) {
        val = '' + val || '';
        if (!val.match(/^[A-Za-z](?:[A-Za-z0-9._-])*$/)) {
          throw new Error("Invalid encoding: " + val);
        }
        return val;
      };
  
      XMLStringifier.prototype.xmlStandalone = function(val) {
        if (val) {
          return "yes";
        } else {
          return "no";
        }
      };
  
      XMLStringifier.prototype.dtdPubID = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.dtdSysID = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.dtdElementValue = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.dtdAttType = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.dtdAttDefault = function(val) {
        if (val != null) {
          return '' + val || '';
        } else {
          return val;
        }
      };
  
      XMLStringifier.prototype.dtdEntityValue = function(val) {
        return '' + val || '';
      };
  
      XMLStringifier.prototype.dtdNData = function(val) {
        return '' + 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 res;
        res = str.match(/[\0\uFFFE\uFFFF]|[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?:[^\uD800-\uDBFF]|^)[\uDC00-\uDFFF]/);
        if (res) {
          throw new Error("Invalid character in string: " + str + " at index " + res.index);
        }
        return str;
      };
  
      XMLStringifier.prototype.elEscape = function(str) {
        var ampregex;
        ampregex = this.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;
        ampregex = this.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);
  
  
  /***/ }),
  
  /***/ 7329:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLNode, 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;
  
    XMLNode = __nccwpck_require__(4736);
  
    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.value = this.stringify.eleText(text);
      }
  
      XMLText.prototype.clone = function() {
        return Object.create(this);
      };
  
      XMLText.prototype.toString = function(options) {
        return this.options.writer.set(options).text(this);
      };
  
      return XMLText;
  
    })(XMLNode);
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 7846:
  /***/ (function(module) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLWriterBase,
      hasProp = {}.hasOwnProperty;
  
    module.exports = XMLWriterBase = (function() {
      function XMLWriterBase(options) {
        var key, ref, ref1, ref2, ref3, ref4, ref5, ref6, value;
        options || (options = {});
        this.pretty = options.pretty || false;
        this.allowEmpty = (ref = options.allowEmpty) != null ? ref : false;
        if (this.pretty) {
          this.indent = (ref1 = options.indent) != null ? ref1 : '  ';
          this.newline = (ref2 = options.newline) != null ? ref2 : '\n';
          this.offset = (ref3 = options.offset) != null ? ref3 : 0;
          this.dontprettytextnodes = (ref4 = options.dontprettytextnodes) != null ? ref4 : 0;
        } else {
          this.indent = '';
          this.newline = '';
          this.offset = 0;
          this.dontprettytextnodes = 0;
        }
        this.spacebeforeslash = (ref5 = options.spacebeforeslash) != null ? ref5 : '';
        if (this.spacebeforeslash === true) {
          this.spacebeforeslash = ' ';
        }
        this.newlinedefault = this.newline;
        this.prettydefault = this.pretty;
        ref6 = options.writer || {};
        for (key in ref6) {
          if (!hasProp.call(ref6, key)) continue;
          value = ref6[key];
          this[key] = value;
        }
      }
  
      XMLWriterBase.prototype.set = function(options) {
        var key, ref, value;
        options || (options = {});
        if ("pretty" in options) {
          this.pretty = options.pretty;
        }
        if ("allowEmpty" in options) {
          this.allowEmpty = options.allowEmpty;
        }
        if (this.pretty) {
          this.indent = "indent" in options ? options.indent : '  ';
          this.newline = "newline" in options ? options.newline : '\n';
          this.offset = "offset" in options ? options.offset : 0;
          this.dontprettytextnodes = "dontprettytextnodes" in options ? options.dontprettytextnodes : 0;
        } else {
          this.indent = '';
          this.newline = '';
          this.offset = 0;
          this.dontprettytextnodes = 0;
        }
        this.spacebeforeslash = "spacebeforeslash" in options ? options.spacebeforeslash : '';
        if (this.spacebeforeslash === true) {
          this.spacebeforeslash = ' ';
        }
        this.newlinedefault = this.newline;
        this.prettydefault = this.pretty;
        ref = options.writer || {};
        for (key in ref) {
          if (!hasProp.call(ref, key)) continue;
          value = ref[key];
          this[key] = value;
        }
        return this;
      };
  
      XMLWriterBase.prototype.space = function(level) {
        var indent;
        if (this.pretty) {
          indent = (level || 0) + this.offset + 1;
          if (indent > 0) {
            return new Array(indent).join(this.indent);
          } else {
            return '';
          }
        } else {
          return '';
        }
      };
  
      return XMLWriterBase;
  
    })();
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 6966:
  /***/ (function(module, __unused_webpack_exports, __nccwpck_require__) {
  
  // Generated by CoffeeScript 1.12.7
  (function() {
    var XMLDocument, XMLDocumentCB, XMLStreamWriter, XMLStringWriter, assign, isFunction, ref;
  
    ref = __nccwpck_require__(1968), assign = ref.assign, isFunction = ref.isFunction;
  
    XMLDocument = __nccwpck_require__(1139);
  
    XMLDocumentCB = __nccwpck_require__(4285);
  
    XMLStringWriter = __nccwpck_require__(9024);
  
    XMLStreamWriter = __nccwpck_require__(4088);
  
    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.doctype(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);
    };
  
  }).call(this);
  
  
  /***/ }),
  
  /***/ 558:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var __webpack_unused_export__;
  function DOMParser(options){
  	this.options = options ||{locator:{}};
  }
  
  DOMParser.prototype.parseFromString = function(source,mimeType){
  	var options = this.options;
  	var sax =  new XMLReader();
  	var domBuilder = options.domBuilder || new DOMHandler();//contentHandler and LexicalHandler
  	var errorHandler = options.errorHandler;
  	var locator = options.locator;
  	var defaultNSMap = options.xmlns||{};
  	var isHTML = /\/x?html?$/.test(mimeType);//mimeType.toLowerCase().indexOf('html') > -1;
    	var entityMap = isHTML?htmlEntity.entityMap:{'lt':'<','gt':'>','amp':'&','quot':'"','apos':"'"};
  	if(locator){
  		domBuilder.setDocumentLocator(locator)
  	}
  
  	sax.errorHandler = buildErrorHandler(errorHandler,domBuilder,locator);
  	sax.domBuilder = options.domBuilder || domBuilder;
  	if(isHTML){
  		defaultNSMap['']= 'http://www.w3.org/1999/xhtml';
  	}
  	defaultNSMap.xml = defaultNSMap.xml || 'http://www.w3.org/XML/1998/namespace';
  	if(source && typeof source === 'string'){
  		sax.parse(source,defaultNSMap,entityMap);
  	}else{
  		sax.errorHandler.error("invalid doc source");
  	}
  	return domBuilder.doc;
  }
  function buildErrorHandler(errorImpl,domBuilder,locator){
  	if(!errorImpl){
  		if(domBuilder instanceof DOMHandler){
  			return domBuilder;
  		}
  		errorImpl = domBuilder ;
  	}
  	var errorHandler = {}
  	var isCallback = errorImpl instanceof Function;
  	locator = locator||{}
  	function build(key){
  		var fn = errorImpl[key];
  		if(!fn && isCallback){
  			fn = errorImpl.length == 2?function(msg){errorImpl(key,msg)}:errorImpl;
  		}
  		errorHandler[key] = fn && function(msg){
  			fn('[xmldom '+key+']\t'+msg+_locator(locator));
  		}||function(){};
  	}
  	build('warning');
  	build('error');
  	build('fatalError');
  	return errorHandler;
  }
  
  //console.log('#\n\n\n\n\n\n\n####')
  /**
   * +ContentHandler+ErrorHandler
   * +LexicalHandler+EntityResolver2
   * -DeclHandler-DTDHandler
   *
   * DefaultHandler:EntityResolver, DTDHandler, ContentHandler, ErrorHandler
   * DefaultHandler2:DefaultHandler,LexicalHandler, DeclHandler, EntityResolver2
   * @link http://www.saxproject.org/apidoc/org/xml/sax/helpers/DefaultHandler.html
   */
  function DOMHandler() {
      this.cdata = false;
  }
  function position(locator,node){
  	node.lineNumber = locator.lineNumber;
  	node.columnNumber = locator.columnNumber;
  }
  /**
   * @see org.xml.sax.ContentHandler#startDocument
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ContentHandler.html
   */
  DOMHandler.prototype = {
  	startDocument : function() {
      	this.doc = new DOMImplementation().createDocument(null, null, null);
      	if (this.locator) {
          	this.doc.documentURI = this.locator.systemId;
      	}
  	},
  	startElement:function(namespaceURI, localName, qName, attrs) {
  		var doc = this.doc;
  	    var el = doc.createElementNS(namespaceURI, qName||localName);
  	    var len = attrs.length;
  	    appendElement(this, el);
  	    this.currentElement = el;
  
  		this.locator && position(this.locator,el)
  	    for (var i = 0 ; i < len; i++) {
  	        var namespaceURI = attrs.getURI(i);
  	        var value = attrs.getValue(i);
  	        var qName = attrs.getQName(i);
  			var attr = doc.createAttributeNS(namespaceURI, qName);
  			this.locator &&position(attrs.getLocator(i),attr);
  			attr.value = attr.nodeValue = value;
  			el.setAttributeNode(attr)
  	    }
  	},
  	endElement:function(namespaceURI, localName, qName) {
  		var current = this.currentElement
  		var tagName = current.tagName;
  		this.currentElement = current.parentNode;
  	},
  	startPrefixMapping:function(prefix, uri) {
  	},
  	endPrefixMapping:function(prefix) {
  	},
  	processingInstruction:function(target, data) {
  	    var ins = this.doc.createProcessingInstruction(target, data);
  	    this.locator && position(this.locator,ins)
  	    appendElement(this, ins);
  	},
  	ignorableWhitespace:function(ch, start, length) {
  	},
  	characters:function(chars, start, length) {
  		chars = _toString.apply(this,arguments)
  		//console.log(chars)
  		if(chars){
  			if (this.cdata) {
  				var charNode = this.doc.createCDATASection(chars);
  			} else {
  				var charNode = this.doc.createTextNode(chars);
  			}
  			if(this.currentElement){
  				this.currentElement.appendChild(charNode);
  			}else if(/^\s*$/.test(chars)){
  				this.doc.appendChild(charNode);
  				//process xml
  			}
  			this.locator && position(this.locator,charNode)
  		}
  	},
  	skippedEntity:function(name) {
  	},
  	endDocument:function() {
  		this.doc.normalize();
  	},
  	setDocumentLocator:function (locator) {
  	    if(this.locator = locator){// && !('lineNumber' in locator)){
  	    	locator.lineNumber = 0;
  	    }
  	},
  	//LexicalHandler
  	comment:function(chars, start, length) {
  		chars = _toString.apply(this,arguments)
  	    var comm = this.doc.createComment(chars);
  	    this.locator && position(this.locator,comm)
  	    appendElement(this, comm);
  	},
  
  	startCDATA:function() {
  	    //used in characters() methods
  	    this.cdata = true;
  	},
  	endCDATA:function() {
  	    this.cdata = false;
  	},
  
  	startDTD:function(name, publicId, systemId) {
  		var impl = this.doc.implementation;
  	    if (impl && impl.createDocumentType) {
  	        var dt = impl.createDocumentType(name, publicId, systemId);
  	        this.locator && position(this.locator,dt)
  	        appendElement(this, dt);
  	    }
  	},
  	/**
  	 * @see org.xml.sax.ErrorHandler
  	 * @link http://www.saxproject.org/apidoc/org/xml/sax/ErrorHandler.html
  	 */
  	warning:function(error) {
  		console.warn('[xmldom warning]\t'+error,_locator(this.locator));
  	},
  	error:function(error) {
  		console.error('[xmldom error]\t'+error,_locator(this.locator));
  	},
  	fatalError:function(error) {
  		throw new ParseError(error, this.locator);
  	}
  }
  function _locator(l){
  	if(l){
  		return '\n@'+(l.systemId ||'')+'#[line:'+l.lineNumber+',col:'+l.columnNumber+']'
  	}
  }
  function _toString(chars,start,length){
  	if(typeof chars == 'string'){
  		return chars.substr(start,length)
  	}else{//java sax connect width xmldom on rhino(what about: "? && !(chars instanceof String)")
  		if(chars.length >= start+length || start){
  			return new java.lang.String(chars,start,length)+'';
  		}
  		return chars;
  	}
  }
  
  /*
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/LexicalHandler.html
   * used method of org.xml.sax.ext.LexicalHandler:
   *  #comment(chars, start, length)
   *  #startCDATA()
   *  #endCDATA()
   *  #startDTD(name, publicId, systemId)
   *
   *
   * IGNORED method of org.xml.sax.ext.LexicalHandler:
   *  #endDTD()
   *  #startEntity(name)
   *  #endEntity(name)
   *
   *
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/DeclHandler.html
   * IGNORED method of org.xml.sax.ext.DeclHandler
   * 	#attributeDecl(eName, aName, type, mode, value)
   *  #elementDecl(name, model)
   *  #externalEntityDecl(name, publicId, systemId)
   *  #internalEntityDecl(name, value)
   * @link http://www.saxproject.org/apidoc/org/xml/sax/ext/EntityResolver2.html
   * IGNORED method of org.xml.sax.EntityResolver2
   *  #resolveEntity(String name,String publicId,String baseURI,String systemId)
   *  #resolveEntity(publicId, systemId)
   *  #getExternalSubset(name, baseURI)
   * @link http://www.saxproject.org/apidoc/org/xml/sax/DTDHandler.html
   * IGNORED method of org.xml.sax.DTDHandler
   *  #notationDecl(name, publicId, systemId) {};
   *  #unparsedEntityDecl(name, publicId, systemId, notationName) {};
   */
  "endDTD,startEntity,endEntity,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,resolveEntity,getExternalSubset,notationDecl,unparsedEntityDecl".replace(/\w+/g,function(key){
  	DOMHandler.prototype[key] = function(){return null}
  })
  
  /* Private static helpers treated below as private instance methods, so don't need to add these to the public API; we might use a Relator to also get rid of non-standard public properties */
  function appendElement (hander,node) {
      if (!hander.currentElement) {
          hander.doc.appendChild(node);
      } else {
          hander.currentElement.appendChild(node);
      }
  }//appendChild and setAttributeNS are preformance key
  
  //if(typeof require == 'function'){
  var htmlEntity = __nccwpck_require__(3793);
  var sax = __nccwpck_require__(4138);
  var XMLReader = sax.XMLReader;
  var ParseError = sax.ParseError;
  var DOMImplementation = /* unused reexport */ __nccwpck_require__(1355).DOMImplementation;
  /* unused reexport */ __nccwpck_require__(1355) ;
  exports.a = DOMParser;
  __webpack_unused_export__ = DOMHandler;
  //}
  
  
  /***/ }),
  
  /***/ 1355:
  /***/ ((__unused_webpack_module, exports) => {
  
  var __webpack_unused_export__;
  function copy(src,dest){
  	for(var p in src){
  		dest[p] = src[p];
  	}
  }
  /**
  ^\w+\.prototype\.([_\w]+)\s*=\s*((?:.*\{\s*?[\r\n][\s\S]*?^})|\S.*?(?=[;\r\n]));?
  ^\w+\.prototype\.([_\w]+)\s*=\s*(\S.*?(?=[;\r\n]));?
   */
  function _extends(Class,Super){
  	var pt = Class.prototype;
  	if(!(pt instanceof Super)){
  		function t(){};
  		t.prototype = Super.prototype;
  		t = new t();
  		copy(pt,t);
  		Class.prototype = pt = t;
  	}
  	if(pt.constructor != Class){
  		if(typeof Class != 'function'){
  			console.error("unknow Class:"+Class)
  		}
  		pt.constructor = Class
  	}
  }
  var htmlns = 'http://www.w3.org/1999/xhtml' ;
  // Node Types
  var NodeType = {}
  var ELEMENT_NODE                = NodeType.ELEMENT_NODE                = 1;
  var ATTRIBUTE_NODE              = NodeType.ATTRIBUTE_NODE              = 2;
  var TEXT_NODE                   = NodeType.TEXT_NODE                   = 3;
  var CDATA_SECTION_NODE          = NodeType.CDATA_SECTION_NODE          = 4;
  var ENTITY_REFERENCE_NODE       = NodeType.ENTITY_REFERENCE_NODE       = 5;
  var ENTITY_NODE                 = NodeType.ENTITY_NODE                 = 6;
  var PROCESSING_INSTRUCTION_NODE = NodeType.PROCESSING_INSTRUCTION_NODE = 7;
  var COMMENT_NODE                = NodeType.COMMENT_NODE                = 8;
  var DOCUMENT_NODE               = NodeType.DOCUMENT_NODE               = 9;
  var DOCUMENT_TYPE_NODE          = NodeType.DOCUMENT_TYPE_NODE          = 10;
  var DOCUMENT_FRAGMENT_NODE      = NodeType.DOCUMENT_FRAGMENT_NODE      = 11;
  var NOTATION_NODE               = NodeType.NOTATION_NODE               = 12;
  
  // ExceptionCode
  var ExceptionCode = {}
  var ExceptionMessage = {};
  var INDEX_SIZE_ERR              = ExceptionCode.INDEX_SIZE_ERR              = ((ExceptionMessage[1]="Index size error"),1);
  var DOMSTRING_SIZE_ERR          = ExceptionCode.DOMSTRING_SIZE_ERR          = ((ExceptionMessage[2]="DOMString size error"),2);
  var HIERARCHY_REQUEST_ERR       = ExceptionCode.HIERARCHY_REQUEST_ERR       = ((ExceptionMessage[3]="Hierarchy request error"),3);
  var WRONG_DOCUMENT_ERR          = ExceptionCode.WRONG_DOCUMENT_ERR          = ((ExceptionMessage[4]="Wrong document"),4);
  var INVALID_CHARACTER_ERR       = ExceptionCode.INVALID_CHARACTER_ERR       = ((ExceptionMessage[5]="Invalid character"),5);
  var NO_DATA_ALLOWED_ERR         = ExceptionCode.NO_DATA_ALLOWED_ERR         = ((ExceptionMessage[6]="No data allowed"),6);
  var NO_MODIFICATION_ALLOWED_ERR = ExceptionCode.NO_MODIFICATION_ALLOWED_ERR = ((ExceptionMessage[7]="No modification allowed"),7);
  var NOT_FOUND_ERR               = ExceptionCode.NOT_FOUND_ERR               = ((ExceptionMessage[8]="Not found"),8);
  var NOT_SUPPORTED_ERR           = ExceptionCode.NOT_SUPPORTED_ERR           = ((ExceptionMessage[9]="Not supported"),9);
  var INUSE_ATTRIBUTE_ERR         = ExceptionCode.INUSE_ATTRIBUTE_ERR         = ((ExceptionMessage[10]="Attribute in use"),10);
  //level2
  var INVALID_STATE_ERR        	= ExceptionCode.INVALID_STATE_ERR        	= ((ExceptionMessage[11]="Invalid state"),11);
  var SYNTAX_ERR               	= ExceptionCode.SYNTAX_ERR               	= ((ExceptionMessage[12]="Syntax error"),12);
  var INVALID_MODIFICATION_ERR 	= ExceptionCode.INVALID_MODIFICATION_ERR 	= ((ExceptionMessage[13]="Invalid modification"),13);
  var NAMESPACE_ERR            	= ExceptionCode.NAMESPACE_ERR           	= ((ExceptionMessage[14]="Invalid namespace"),14);
  var INVALID_ACCESS_ERR       	= ExceptionCode.INVALID_ACCESS_ERR      	= ((ExceptionMessage[15]="Invalid access"),15);
  
  /**
   * DOM Level 2
   * Object DOMException
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/ecma-script-binding.html
   * @see http://www.w3.org/TR/REC-DOM-Level-1/ecma-script-language-binding.html
   */
  function DOMException(code, message) {
  	if(message instanceof Error){
  		var error = message;
  	}else{
  		error = this;
  		Error.call(this, ExceptionMessage[code]);
  		this.message = ExceptionMessage[code];
  		if(Error.captureStackTrace) Error.captureStackTrace(this, DOMException);
  	}
  	error.code = code;
  	if(message) this.message = this.message + ": " + message;
  	return error;
  };
  DOMException.prototype = Error.prototype;
  copy(ExceptionCode,DOMException)
  /**
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-536297177
   * The NodeList interface provides the abstraction of an ordered collection of nodes, without defining or constraining how this collection is implemented. NodeList objects in the DOM are live.
   * The items in the NodeList are accessible via an integral index, starting from 0.
   */
  function NodeList() {
  };
  NodeList.prototype = {
  	/**
  	 * The number of nodes in the list. The range of valid child node indices is 0 to length-1 inclusive.
  	 * @standard level1
  	 */
  	length:0, 
  	/**
  	 * Returns the indexth item in the collection. If index is greater than or equal to the number of nodes in the list, this returns null.
  	 * @standard level1
  	 * @param index  unsigned long 
  	 *   Index into the collection.
  	 * @return Node
  	 * 	The node at the indexth position in the NodeList, or null if that is not a valid index. 
  	 */
  	item: function(index) {
  		return this[index] || null;
  	},
  	toString:function(isHTML,nodeFilter){
  		for(var buf = [], i = 0;i<this.length;i++){
  			serializeToString(this[i],buf,isHTML,nodeFilter);
  		}
  		return buf.join('');
  	}
  };
  function LiveNodeList(node,refresh){
  	this._node = node;
  	this._refresh = refresh
  	_updateLiveList(this);
  }
  function _updateLiveList(list){
  	var inc = list._node._inc || list._node.ownerDocument._inc;
  	if(list._inc != inc){
  		var ls = list._refresh(list._node);
  		//console.log(ls.length)
  		__set__(list,'length',ls.length);
  		copy(ls,list);
  		list._inc = inc;
  	}
  }
  LiveNodeList.prototype.item = function(i){
  	_updateLiveList(this);
  	return this[i];
  }
  
  _extends(LiveNodeList,NodeList);
  /**
   * 
   * Objects implementing the NamedNodeMap interface are used to represent collections of nodes that can be accessed by name. Note that NamedNodeMap does not inherit from NodeList; NamedNodeMaps are not maintained in any particular order. Objects contained in an object implementing NamedNodeMap may also be accessed by an ordinal index, but this is simply to allow convenient enumeration of the contents of a NamedNodeMap, and does not imply that the DOM specifies an order to these Nodes.
   * NamedNodeMap objects in the DOM are live.
   * used for attributes or DocumentType entities 
   */
  function NamedNodeMap() {
  };
  
  function _findNodeIndex(list,node){
  	var i = list.length;
  	while(i--){
  		if(list[i] === node){return i}
  	}
  }
  
  function _addNamedNode(el,list,newAttr,oldAttr){
  	if(oldAttr){
  		list[_findNodeIndex(list,oldAttr)] = newAttr;
  	}else{
  		list[list.length++] = newAttr;
  	}
  	if(el){
  		newAttr.ownerElement = el;
  		var doc = el.ownerDocument;
  		if(doc){
  			oldAttr && _onRemoveAttribute(doc,el,oldAttr);
  			_onAddAttribute(doc,el,newAttr);
  		}
  	}
  }
  function _removeNamedNode(el,list,attr){
  	//console.log('remove attr:'+attr)
  	var i = _findNodeIndex(list,attr);
  	if(i>=0){
  		var lastIndex = list.length-1
  		while(i<lastIndex){
  			list[i] = list[++i]
  		}
  		list.length = lastIndex;
  		if(el){
  			var doc = el.ownerDocument;
  			if(doc){
  				_onRemoveAttribute(doc,el,attr);
  				attr.ownerElement = null;
  			}
  		}
  	}else{
  		throw DOMException(NOT_FOUND_ERR,new Error(el.tagName+'@'+attr))
  	}
  }
  NamedNodeMap.prototype = {
  	length:0,
  	item:NodeList.prototype.item,
  	getNamedItem: function(key) {
  //		if(key.indexOf(':')>0 || key == 'xmlns'){
  //			return null;
  //		}
  		//console.log()
  		var i = this.length;
  		while(i--){
  			var attr = this[i];
  			//console.log(attr.nodeName,key)
  			if(attr.nodeName == key){
  				return attr;
  			}
  		}
  	},
  	setNamedItem: function(attr) {
  		var el = attr.ownerElement;
  		if(el && el!=this._ownerElement){
  			throw new DOMException(INUSE_ATTRIBUTE_ERR);
  		}
  		var oldAttr = this.getNamedItem(attr.nodeName);
  		_addNamedNode(this._ownerElement,this,attr,oldAttr);
  		return oldAttr;
  	},
  	/* returns Node */
  	setNamedItemNS: function(attr) {// raises: WRONG_DOCUMENT_ERR,NO_MODIFICATION_ALLOWED_ERR,INUSE_ATTRIBUTE_ERR
  		var el = attr.ownerElement, oldAttr;
  		if(el && el!=this._ownerElement){
  			throw new DOMException(INUSE_ATTRIBUTE_ERR);
  		}
  		oldAttr = this.getNamedItemNS(attr.namespaceURI,attr.localName);
  		_addNamedNode(this._ownerElement,this,attr,oldAttr);
  		return oldAttr;
  	},
  
  	/* returns Node */
  	removeNamedItem: function(key) {
  		var attr = this.getNamedItem(key);
  		_removeNamedNode(this._ownerElement,this,attr);
  		return attr;
  		
  		
  	},// raises: NOT_FOUND_ERR,NO_MODIFICATION_ALLOWED_ERR
  	
  	//for level2
  	removeNamedItemNS:function(namespaceURI,localName){
  		var attr = this.getNamedItemNS(namespaceURI,localName);
  		_removeNamedNode(this._ownerElement,this,attr);
  		return attr;
  	},
  	getNamedItemNS: function(namespaceURI, localName) {
  		var i = this.length;
  		while(i--){
  			var node = this[i];
  			if(node.localName == localName && node.namespaceURI == namespaceURI){
  				return node;
  			}
  		}
  		return null;
  	}
  };
  /**
   * @see http://www.w3.org/TR/REC-DOM-Level-1/level-one-core.html#ID-102161490
   */
  function DOMImplementation(/* Object */ features) {
  	this._features = {};
  	if (features) {
  		for (var feature in features) {
  			 this._features = features[feature];
  		}
  	}
  };
  
  DOMImplementation.prototype = {
  	hasFeature: function(/* string */ feature, /* string */ version) {
  		var versions = this._features[feature.toLowerCase()];
  		if (versions && (!version || version in versions)) {
  			return true;
  		} else {
  			return false;
  		}
  	},
  	// Introduced in DOM Level 2:
  	createDocument:function(namespaceURI,  qualifiedName, doctype){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR,WRONG_DOCUMENT_ERR
  		var doc = new Document();
  		doc.implementation = this;
  		doc.childNodes = new NodeList();
  		doc.doctype = doctype;
  		if(doctype){
  			doc.appendChild(doctype);
  		}
  		if(qualifiedName){
  			var root = doc.createElementNS(namespaceURI,qualifiedName);
  			doc.appendChild(root);
  		}
  		return doc;
  	},
  	// Introduced in DOM Level 2:
  	createDocumentType:function(qualifiedName, publicId, systemId){// raises:INVALID_CHARACTER_ERR,NAMESPACE_ERR
  		var node = new DocumentType();
  		node.name = qualifiedName;
  		node.nodeName = qualifiedName;
  		node.publicId = publicId;
  		node.systemId = systemId;
  		// Introduced in DOM Level 2:
  		//readonly attribute DOMString        internalSubset;
  		
  		//TODO:..
  		//  readonly attribute NamedNodeMap     entities;
  		//  readonly attribute NamedNodeMap     notations;
  		return node;
  	}
  };
  
  
  /**
   * @see http://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#ID-1950641247
   */
  
  function Node() {
  };
  
  Node.prototype = {
  	firstChild : null,
  	lastChild : null,
  	previousSibling : null,
  	nextSibling : null,
  	attributes : null,
  	parentNode : null,
  	childNodes : null,
  	ownerDocument : null,
  	nodeValue : null,
  	namespaceURI : null,
  	prefix : null,
  	localName : null,
  	// Modified in DOM Level 2:
  	insertBefore:function(newChild, refChild){//raises 
  		return _insertBefore(this,newChild,refChild);
  	},
  	replaceChild:function(newChild, oldChild){//raises 
  		this.insertBefore(newChild,oldChild);
  		if(oldChild){
  			this.removeChild(oldChild);
  		}
  	},
  	removeChild:function(oldChild){
  		return _removeChild(this,oldChild);
  	},
  	appendChild:function(newChild){
  		return this.insertBefore(newChild,null);
  	},
  	hasChildNodes:function(){
  		return this.firstChild != null;
  	},
  	cloneNode:function(deep){
  		return cloneNode(this.ownerDocument||this,this,deep);
  	},
  	// Modified in DOM Level 2:
  	normalize:function(){
  		var child = this.firstChild;
  		while(child){
  			var next = child.nextSibling;
  			if(next && next.nodeType == TEXT_NODE && child.nodeType == TEXT_NODE){
  				this.removeChild(next);
  				child.appendData(next.data);
  			}else{
  				child.normalize();
  				child = next;
  			}
  		}
  	},
    	// Introduced in DOM Level 2:
  	isSupported:function(feature, version){
  		return this.ownerDocument.implementation.hasFeature(feature,version);
  	},
      // Introduced in DOM Level 2:
      hasAttributes:function(){
      	return this.attributes.length>0;
      },
      lookupPrefix:function(namespaceURI){
      	var el = this;
      	while(el){
      		var map = el._nsMap;
      		//console.dir(map)
      		if(map){
      			for(var n in map){
      				if(map[n] == namespaceURI){
      					return n;
      				}
      			}
      		}
      		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
      	}
      	return null;
      },
      // Introduced in DOM Level 3:
      lookupNamespaceURI:function(prefix){
      	var el = this;
      	while(el){
      		var map = el._nsMap;
      		//console.dir(map)
      		if(map){
      			if(prefix in map){
      				return map[prefix] ;
      			}
      		}
      		el = el.nodeType == ATTRIBUTE_NODE?el.ownerDocument : el.parentNode;
      	}
      	return null;
      },
      // Introduced in DOM Level 3:
      isDefaultNamespace:function(namespaceURI){
      	var prefix = this.lookupPrefix(namespaceURI);
      	return prefix == null;
      }
  };
  
  
  function _xmlEncoder(c){
  	return c == '<' && '&lt;' ||
           c == '>' && '&gt;' ||
           c == '&' && '&amp;' ||
           c == '"' && '&quot;' ||
           '&#'+c.charCodeAt()+';'
  }
  
  
  copy(NodeType,Node);
  copy(NodeType,Node.prototype);
  
  /**
   * @param callback return true for continue,false for break
   * @return boolean true: break visit;
   */
  function _visitNode(node,callback){
  	if(callback(node)){
  		return true;
  	}
  	if(node = node.firstChild){
  		do{
  			if(_visitNode(node,callback)){return true}
          }while(node=node.nextSibling)
      }
  }
  
  
  
  function Document(){
  }
  function _onAddAttribute(doc,el,newAttr){
  	doc && doc._inc++;
  	var ns = newAttr.namespaceURI ;
  	if(ns == 'http://www.w3.org/2000/xmlns/'){
  		//update namespace
  		el._nsMap[newAttr.prefix?newAttr.localName:''] = newAttr.value
  	}
  }
  function _onRemoveAttribute(doc,el,newAttr,remove){
  	doc && doc._inc++;
  	var ns = newAttr.namespaceURI ;
  	if(ns == 'http://www.w3.org/2000/xmlns/'){
  		//update namespace
  		delete el._nsMap[newAttr.prefix?newAttr.localName:'']
  	}
  }
  function _onUpdateChild(doc,el,newChild){
  	if(doc && doc._inc){
  		doc._inc++;
  		//update childNodes
  		var cs = el.childNodes;
  		if(newChild){
  			cs[cs.length++] = newChild;
  		}else{
  			//console.log(1)
  			var child = el.firstChild;
  			var i = 0;
  			while(child){
  				cs[i++] = child;
  				child =child.nextSibling;
  			}
  			cs.length = i;
  		}
  	}
  }
  
  /**
   * attributes;
   * children;
   * 
   * writeable properties:
   * nodeValue,Attr:value,CharacterData:data
   * prefix
   */
  function _removeChild(parentNode,child){
  	var previous = child.previousSibling;
  	var next = child.nextSibling;
  	if(previous){
  		previous.nextSibling = next;
  	}else{
  		parentNode.firstChild = next
  	}
  	if(next){
  		next.previousSibling = previous;
  	}else{
  		parentNode.lastChild = previous;
  	}
  	_onUpdateChild(parentNode.ownerDocument,parentNode);
  	return child;
  }
  /**
   * preformance key(refChild == null)
   */
  function _insertBefore(parentNode,newChild,nextChild){
  	var cp = newChild.parentNode;
  	if(cp){
  		cp.removeChild(newChild);//remove and update
  	}
  	if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
  		var newFirst = newChild.firstChild;
  		if (newFirst == null) {
  			return newChild;
  		}
  		var newLast = newChild.lastChild;
  	}else{
  		newFirst = newLast = newChild;
  	}
  	var pre = nextChild ? nextChild.previousSibling : parentNode.lastChild;
  
  	newFirst.previousSibling = pre;
  	newLast.nextSibling = nextChild;
  	
  	
  	if(pre){
  		pre.nextSibling = newFirst;
  	}else{
  		parentNode.firstChild = newFirst;
  	}
  	if(nextChild == null){
  		parentNode.lastChild = newLast;
  	}else{
  		nextChild.previousSibling = newLast;
  	}
  	do{
  		newFirst.parentNode = parentNode;
  	}while(newFirst !== newLast && (newFirst= newFirst.nextSibling))
  	_onUpdateChild(parentNode.ownerDocument||parentNode,parentNode);
  	//console.log(parentNode.lastChild.nextSibling == null)
  	if (newChild.nodeType == DOCUMENT_FRAGMENT_NODE) {
  		newChild.firstChild = newChild.lastChild = null;
  	}
  	return newChild;
  }
  function _appendSingleChild(parentNode,newChild){
  	var cp = newChild.parentNode;
  	if(cp){
  		var pre = parentNode.lastChild;
  		cp.removeChild(newChild);//remove and update
  		var pre = parentNode.lastChild;
  	}
  	var pre = parentNode.lastChild;
  	newChild.parentNode = parentNode;
  	newChild.previousSibling = pre;
  	newChild.nextSibling = null;
  	if(pre){
  		pre.nextSibling = newChild;
  	}else{
  		parentNode.firstChild = newChild;
  	}
  	parentNode.lastChild = newChild;
  	_onUpdateChild(parentNode.ownerDocument,parentNode,newChild);
  	return newChild;
  	//console.log("__aa",parentNode.lastChild.nextSibling == null)
  }
  Document.prototype = {
  	//implementation : null,
  	nodeName :  '#document',
  	nodeType :  DOCUMENT_NODE,
  	doctype :  null,
  	documentElement :  null,
  	_inc : 1,
  	
  	insertBefore :  function(newChild, refChild){//raises 
  		if(newChild.nodeType == DOCUMENT_FRAGMENT_NODE){
  			var child = newChild.firstChild;
  			while(child){
  				var next = child.nextSibling;
  				this.insertBefore(child,refChild);
  				child = next;
  			}
  			return newChild;
  		}
  		if(this.documentElement == null && newChild.nodeType == ELEMENT_NODE){
  			this.documentElement = newChild;
  		}
  		
  		return _insertBefore(this,newChild,refChild),(newChild.ownerDocument = this),newChild;
  	},
  	removeChild :  function(oldChild){
  		if(this.documentElement == oldChild){
  			this.documentElement = null;
  		}
  		return _removeChild(this,oldChild);
  	},
  	// Introduced in DOM Level 2:
  	importNode : function(importedNode,deep){
  		return importNode(this,importedNode,deep);
  	},
  	// Introduced in DOM Level 2:
  	getElementById :	function(id){
  		var rtv = null;
  		_visitNode(this.documentElement,function(node){
  			if(node.nodeType == ELEMENT_NODE){
  				if(node.getAttribute('id') == id){
  					rtv = node;
  					return true;
  				}
  			}
  		})
  		return rtv;
  	},
  	
  	getElementsByClassName: function(className) {
  		var pattern = new RegExp("(^|\\s)" + className + "(\\s|$)");
  		return new LiveNodeList(this, function(base) {
  			var ls = [];
  			_visitNode(base.documentElement, function(node) {
  				if(node !== base && node.nodeType == ELEMENT_NODE) {
  					if(pattern.test(node.getAttribute('class'))) {
  						ls.push(node);
  					}
  				}
  			});
  			return ls;
  		});
  	},
  	
  	//document factory method:
  	createElement :	function(tagName){
  		var node = new Element();
  		node.ownerDocument = this;
  		node.nodeName = tagName;
  		node.tagName = tagName;
  		node.childNodes = new NodeList();
  		var attrs	= node.attributes = new NamedNodeMap();
  		attrs._ownerElement = node;
  		return node;
  	},
  	createDocumentFragment :	function(){
  		var node = new DocumentFragment();
  		node.ownerDocument = this;
  		node.childNodes = new NodeList();
  		return node;
  	},
  	createTextNode :	function(data){
  		var node = new Text();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createComment :	function(data){
  		var node = new Comment();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createCDATASection :	function(data){
  		var node = new CDATASection();
  		node.ownerDocument = this;
  		node.appendData(data)
  		return node;
  	},
  	createProcessingInstruction :	function(target,data){
  		var node = new ProcessingInstruction();
  		node.ownerDocument = this;
  		node.tagName = node.target = target;
  		node.nodeValue= node.data = data;
  		return node;
  	},
  	createAttribute :	function(name){
  		var node = new Attr();
  		node.ownerDocument	= this;
  		node.name = name;
  		node.nodeName	= name;
  		node.localName = name;
  		node.specified = true;
  		return node;
  	},
  	createEntityReference :	function(name){
  		var node = new EntityReference();
  		node.ownerDocument	= this;
  		node.nodeName	= name;
  		return node;
  	},
  	// Introduced in DOM Level 2:
  	createElementNS :	function(namespaceURI,qualifiedName){
  		var node = new Element();
  		var pl = qualifiedName.split(':');
  		var attrs	= node.attributes = new NamedNodeMap();
  		node.childNodes = new NodeList();
  		node.ownerDocument = this;
  		node.nodeName = qualifiedName;
  		node.tagName = qualifiedName;
  		node.namespaceURI = namespaceURI;
  		if(pl.length == 2){
  			node.prefix = pl[0];
  			node.localName = pl[1];
  		}else{
  			//el.prefix = null;
  			node.localName = qualifiedName;
  		}
  		attrs._ownerElement = node;
  		return node;
  	},
  	// Introduced in DOM Level 2:
  	createAttributeNS :	function(namespaceURI,qualifiedName){
  		var node = new Attr();
  		var pl = qualifiedName.split(':');
  		node.ownerDocument = this;
  		node.nodeName = qualifiedName;
  		node.name = qualifiedName;
  		node.namespaceURI = namespaceURI;
  		node.specified = true;
  		if(pl.length == 2){
  			node.prefix = pl[0];
  			node.localName = pl[1];
  		}else{
  			//el.prefix = null;
  			node.localName = qualifiedName;
  		}
  		return node;
  	}
  };
  _extends(Document,Node);
  
  
  function Element() {
  	this._nsMap = {};
  };
  Element.prototype = {
  	nodeType : ELEMENT_NODE,
  	hasAttribute : function(name){
  		return this.getAttributeNode(name)!=null;
  	},
  	getAttribute : function(name){
  		var attr = this.getAttributeNode(name);
  		return attr && attr.value || '';
  	},
  	getAttributeNode : function(name){
  		return this.attributes.getNamedItem(name);
  	},
  	setAttribute : function(name, value){
  		var attr = this.ownerDocument.createAttribute(name);
  		attr.value = attr.nodeValue = "" + value;
  		this.setAttributeNode(attr)
  	},
  	removeAttribute : function(name){
  		var attr = this.getAttributeNode(name)
  		attr && this.removeAttributeNode(attr);
  	},
  	
  	//four real opeartion method
  	appendChild:function(newChild){
  		if(newChild.nodeType === DOCUMENT_FRAGMENT_NODE){
  			return this.insertBefore(newChild,null);
  		}else{
  			return _appendSingleChild(this,newChild);
  		}
  	},
  	setAttributeNode : function(newAttr){
  		return this.attributes.setNamedItem(newAttr);
  	},
  	setAttributeNodeNS : function(newAttr){
  		return this.attributes.setNamedItemNS(newAttr);
  	},
  	removeAttributeNode : function(oldAttr){
  		//console.log(this == oldAttr.ownerElement)
  		return this.attributes.removeNamedItem(oldAttr.nodeName);
  	},
  	//get real attribute name,and remove it by removeAttributeNode
  	removeAttributeNS : function(namespaceURI, localName){
  		var old = this.getAttributeNodeNS(namespaceURI, localName);
  		old && this.removeAttributeNode(old);
  	},
  	
  	hasAttributeNS : function(namespaceURI, localName){
  		return this.getAttributeNodeNS(namespaceURI, localName)!=null;
  	},
  	getAttributeNS : function(namespaceURI, localName){
  		var attr = this.getAttributeNodeNS(namespaceURI, localName);
  		return attr && attr.value || '';
  	},
  	setAttributeNS : function(namespaceURI, qualifiedName, value){
  		var attr = this.ownerDocument.createAttributeNS(namespaceURI, qualifiedName);
  		attr.value = attr.nodeValue = "" + value;
  		this.setAttributeNode(attr)
  	},
  	getAttributeNodeNS : function(namespaceURI, localName){
  		return this.attributes.getNamedItemNS(namespaceURI, localName);
  	},
  	
  	getElementsByTagName : function(tagName){
  		return new LiveNodeList(this,function(base){
  			var ls = [];
  			_visitNode(base,function(node){
  				if(node !== base && node.nodeType == ELEMENT_NODE && (tagName === '*' || node.tagName == tagName)){
  					ls.push(node);
  				}
  			});
  			return ls;
  		});
  	},
  	getElementsByTagNameNS : function(namespaceURI, localName){
  		return new LiveNodeList(this,function(base){
  			var ls = [];
  			_visitNode(base,function(node){
  				if(node !== base && node.nodeType === ELEMENT_NODE && (namespaceURI === '*' || node.namespaceURI === namespaceURI) && (localName === '*' || node.localName == localName)){
  					ls.push(node);
  				}
  			});
  			return ls;
  			
  		});
  	}
  };
  Document.prototype.getElementsByTagName = Element.prototype.getElementsByTagName;
  Document.prototype.getElementsByTagNameNS = Element.prototype.getElementsByTagNameNS;
  
  
  _extends(Element,Node);
  function Attr() {
  };
  Attr.prototype.nodeType = ATTRIBUTE_NODE;
  _extends(Attr,Node);
  
  
  function CharacterData() {
  };
  CharacterData.prototype = {
  	data : '',
  	substringData : function(offset, count) {
  		return this.data.substring(offset, offset+count);
  	},
  	appendData: function(text) {
  		text = this.data+text;
  		this.nodeValue = this.data = text;
  		this.length = text.length;
  	},
  	insertData: function(offset,text) {
  		this.replaceData(offset,0,text);
  	
  	},
  	appendChild:function(newChild){
  		throw new Error(ExceptionMessage[HIERARCHY_REQUEST_ERR])
  	},
  	deleteData: function(offset, count) {
  		this.replaceData(offset,count,"");
  	},
  	replaceData: function(offset, count, text) {
  		var start = this.data.substring(0,offset);
  		var end = this.data.substring(offset+count);
  		text = start + text + end;
  		this.nodeValue = this.data = text;
  		this.length = text.length;
  	}
  }
  _extends(CharacterData,Node);
  function Text() {
  };
  Text.prototype = {
  	nodeName : "#text",
  	nodeType : TEXT_NODE,
  	splitText : function(offset) {
  		var text = this.data;
  		var newText = text.substring(offset);
  		text = text.substring(0, offset);
  		this.data = this.nodeValue = text;
  		this.length = text.length;
  		var newNode = this.ownerDocument.createTextNode(newText);
  		if(this.parentNode){
  			this.parentNode.insertBefore(newNode, this.nextSibling);
  		}
  		return newNode;
  	}
  }
  _extends(Text,CharacterData);
  function Comment() {
  };
  Comment.prototype = {
  	nodeName : "#comment",
  	nodeType : COMMENT_NODE
  }
  _extends(Comment,CharacterData);
  
  function CDATASection() {
  };
  CDATASection.prototype = {
  	nodeName : "#cdata-section",
  	nodeType : CDATA_SECTION_NODE
  }
  _extends(CDATASection,CharacterData);
  
  
  function DocumentType() {
  };
  DocumentType.prototype.nodeType = DOCUMENT_TYPE_NODE;
  _extends(DocumentType,Node);
  
  function Notation() {
  };
  Notation.prototype.nodeType = NOTATION_NODE;
  _extends(Notation,Node);
  
  function Entity() {
  };
  Entity.prototype.nodeType = ENTITY_NODE;
  _extends(Entity,Node);
  
  function EntityReference() {
  };
  EntityReference.prototype.nodeType = ENTITY_REFERENCE_NODE;
  _extends(EntityReference,Node);
  
  function DocumentFragment() {
  };
  DocumentFragment.prototype.nodeName =	"#document-fragment";
  DocumentFragment.prototype.nodeType =	DOCUMENT_FRAGMENT_NODE;
  _extends(DocumentFragment,Node);
  
  
  function ProcessingInstruction() {
  }
  ProcessingInstruction.prototype.nodeType = PROCESSING_INSTRUCTION_NODE;
  _extends(ProcessingInstruction,Node);
  function XMLSerializer(){}
  XMLSerializer.prototype.serializeToString = function(node,isHtml,nodeFilter){
  	return nodeSerializeToString.call(node,isHtml,nodeFilter);
  }
  Node.prototype.toString = nodeSerializeToString;
  function nodeSerializeToString(isHtml,nodeFilter){
  	var buf = [];
  	var refNode = this.nodeType == 9 && this.documentElement || this;
  	var prefix = refNode.prefix;
  	var uri = refNode.namespaceURI;
  	
  	if(uri && prefix == null){
  		//console.log(prefix)
  		var prefix = refNode.lookupPrefix(uri);
  		if(prefix == null){
  			//isHTML = true;
  			var visibleNamespaces=[
  			{namespace:uri,prefix:null}
  			//{namespace:uri,prefix:''}
  			]
  		}
  	}
  	serializeToString(this,buf,isHtml,nodeFilter,visibleNamespaces);
  	//console.log('###',this.nodeType,uri,prefix,buf.join(''))
  	return buf.join('');
  }
  function needNamespaceDefine(node,isHTML, visibleNamespaces) {
  	var prefix = node.prefix||'';
  	var uri = node.namespaceURI;
  	if (!prefix && !uri){
  		return false;
  	}
  	if (prefix === "xml" && uri === "http://www.w3.org/XML/1998/namespace" 
  		|| uri == 'http://www.w3.org/2000/xmlns/'){
  		return false;
  	}
  	
  	var i = visibleNamespaces.length 
  	//console.log('@@@@',node.tagName,prefix,uri,visibleNamespaces)
  	while (i--) {
  		var ns = visibleNamespaces[i];
  		// get namespace prefix
  		//console.log(node.nodeType,node.tagName,ns.prefix,prefix)
  		if (ns.prefix == prefix){
  			return ns.namespace != uri;
  		}
  	}
  	//console.log(isHTML,uri,prefix=='')
  	//if(isHTML && prefix ==null && uri == 'http://www.w3.org/1999/xhtml'){
  	//	return false;
  	//}
  	//node.flag = '11111'
  	//console.error(3,true,node.flag,node.prefix,node.namespaceURI)
  	return true;
  }
  function serializeToString(node,buf,isHTML,nodeFilter,visibleNamespaces){
  	if(nodeFilter){
  		node = nodeFilter(node);
  		if(node){
  			if(typeof node == 'string'){
  				buf.push(node);
  				return;
  			}
  		}else{
  			return;
  		}
  		//buf.sort.apply(attrs, attributeSorter);
  	}
  	switch(node.nodeType){
  	case ELEMENT_NODE:
  		if (!visibleNamespaces) visibleNamespaces = [];
  		var startVisibleNamespaces = visibleNamespaces.length;
  		var attrs = node.attributes;
  		var len = attrs.length;
  		var child = node.firstChild;
  		var nodeName = node.tagName;
  		
  		isHTML =  (htmlns === node.namespaceURI) ||isHTML 
  		buf.push('<',nodeName);
  		
  		
  		
  		for(var i=0;i<len;i++){
  			// add namespaces for attributes
  			var attr = attrs.item(i);
  			if (attr.prefix == 'xmlns') {
  				visibleNamespaces.push({ prefix: attr.localName, namespace: attr.value });
  			}else if(attr.nodeName == 'xmlns'){
  				visibleNamespaces.push({ prefix: '', namespace: attr.value });
  			}
  		}
  		for(var i=0;i<len;i++){
  			var attr = attrs.item(i);
  			if (needNamespaceDefine(attr,isHTML, visibleNamespaces)) {
  				var prefix = attr.prefix||'';
  				var uri = attr.namespaceURI;
  				var ns = prefix ? ' xmlns:' + prefix : " xmlns";
  				buf.push(ns, '="' , uri , '"');
  				visibleNamespaces.push({ prefix: prefix, namespace:uri });
  			}
  			serializeToString(attr,buf,isHTML,nodeFilter,visibleNamespaces);
  		}
  		// add namespace for current node		
  		if (needNamespaceDefine(node,isHTML, visibleNamespaces)) {
  			var prefix = node.prefix||'';
  			var uri = node.namespaceURI;
  			var ns = prefix ? ' xmlns:' + prefix : " xmlns";
  			buf.push(ns, '="' , uri , '"');
  			visibleNamespaces.push({ prefix: prefix, namespace:uri });
  		}
  		
  		if(child || isHTML && !/^(?:meta|link|img|br|hr|input)$/i.test(nodeName)){
  			buf.push('>');
  			//if is cdata child node
  			if(isHTML && /^script$/i.test(nodeName)){
  				while(child){
  					if(child.data){
  						buf.push(child.data);
  					}else{
  						serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  					}
  					child = child.nextSibling;
  				}
  			}else
  			{
  				while(child){
  					serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  					child = child.nextSibling;
  				}
  			}
  			buf.push('</',nodeName,'>');
  		}else{
  			buf.push('/>');
  		}
  		// remove added visible namespaces
  		//visibleNamespaces.length = startVisibleNamespaces;
  		return;
  	case DOCUMENT_NODE:
  	case DOCUMENT_FRAGMENT_NODE:
  		var child = node.firstChild;
  		while(child){
  			serializeToString(child,buf,isHTML,nodeFilter,visibleNamespaces);
  			child = child.nextSibling;
  		}
  		return;
  	case ATTRIBUTE_NODE:
  		return buf.push(' ',node.name,'="',node.value.replace(/[&"]/g,_xmlEncoder),'"');
  	case TEXT_NODE:
  		/**
  		 * The ampersand character (&) and the left angle bracket (<) must not appear in their literal form,
  		 * except when used as markup delimiters, or within a comment, a processing instruction, or a CDATA section.
  		 * If they are needed elsewhere, they must be escaped using either numeric character references or the strings
  		 * `&amp;` and `&lt;` respectively.
  		 * The right angle bracket (>) may be represented using the string " &gt; ", and must, for compatibility,
  		 * be escaped using either `&gt;` or a character reference when it appears in the string `]]>` in content,
  		 * when that string is not marking the end of a CDATA section.
  		 *
  		 * In the content of elements, character data is any string of characters
  		 * which does not contain the start-delimiter of any markup
  		 * and does not include the CDATA-section-close delimiter, `]]>`.
  		 *
  		 * @see https://www.w3.org/TR/xml/#NT-CharData
  		 */
  		return buf.push(node.data
  			.replace(/[<&]/g,_xmlEncoder)
  			.replace(/]]>/g, ']]&gt;')
  		);
  	case CDATA_SECTION_NODE:
  		return buf.push( '<![CDATA[',node.data,']]>');
  	case COMMENT_NODE:
  		return buf.push( "<!--",node.data,"-->");
  	case DOCUMENT_TYPE_NODE:
  		var pubid = node.publicId;
  		var sysid = node.systemId;
  		buf.push('<!DOCTYPE ',node.name);
  		if(pubid){
  			buf.push(' PUBLIC ', pubid);
  			if (sysid && sysid!='.') {
  				buf.push(' ', sysid);
  			}
  			buf.push('>');
  		}else if(sysid && sysid!='.'){
  			buf.push(' SYSTEM ', sysid, '>');
  		}else{
  			var sub = node.internalSubset;
  			if(sub){
  				buf.push(" [",sub,"]");
  			}
  			buf.push(">");
  		}
  		return;
  	case PROCESSING_INSTRUCTION_NODE:
  		return buf.push( "<?",node.target," ",node.data,"?>");
  	case ENTITY_REFERENCE_NODE:
  		return buf.push( '&',node.nodeName,';');
  	//case ENTITY_NODE:
  	//case NOTATION_NODE:
  	default:
  		buf.push('??',node.nodeName);
  	}
  }
  function importNode(doc,node,deep){
  	var node2;
  	switch (node.nodeType) {
  	case ELEMENT_NODE:
  		node2 = node.cloneNode(false);
  		node2.ownerDocument = doc;
  		//var attrs = node2.attributes;
  		//var len = attrs.length;
  		//for(var i=0;i<len;i++){
  			//node2.setAttributeNodeNS(importNode(doc,attrs.item(i),deep));
  		//}
  	case DOCUMENT_FRAGMENT_NODE:
  		break;
  	case ATTRIBUTE_NODE:
  		deep = true;
  		break;
  	//case ENTITY_REFERENCE_NODE:
  	//case PROCESSING_INSTRUCTION_NODE:
  	////case TEXT_NODE:
  	//case CDATA_SECTION_NODE:
  	//case COMMENT_NODE:
  	//	deep = false;
  	//	break;
  	//case DOCUMENT_NODE:
  	//case DOCUMENT_TYPE_NODE:
  	//cannot be imported.
  	//case ENTITY_NODE:
  	//case NOTATION_NODE：
  	//can not hit in level3
  	//default:throw e;
  	}
  	if(!node2){
  		node2 = node.cloneNode(false);//false
  	}
  	node2.ownerDocument = doc;
  	node2.parentNode = null;
  	if(deep){
  		var child = node.firstChild;
  		while(child){
  			node2.appendChild(importNode(doc,child,deep));
  			child = child.nextSibling;
  		}
  	}
  	return node2;
  }
  //
  //var _relationMap = {firstChild:1,lastChild:1,previousSibling:1,nextSibling:1,
  //					attributes:1,childNodes:1,parentNode:1,documentElement:1,doctype,};
  function cloneNode(doc,node,deep){
  	var node2 = new node.constructor();
  	for(var n in node){
  		var v = node[n];
  		if(typeof v != 'object' ){
  			if(v != node2[n]){
  				node2[n] = v;
  			}
  		}
  	}
  	if(node.childNodes){
  		node2.childNodes = new NodeList();
  	}
  	node2.ownerDocument = doc;
  	switch (node2.nodeType) {
  	case ELEMENT_NODE:
  		var attrs	= node.attributes;
  		var attrs2	= node2.attributes = new NamedNodeMap();
  		var len = attrs.length
  		attrs2._ownerElement = node2;
  		for(var i=0;i<len;i++){
  			node2.setAttributeNode(cloneNode(doc,attrs.item(i),true));
  		}
  		break;;
  	case ATTRIBUTE_NODE:
  		deep = true;
  	}
  	if(deep){
  		var child = node.firstChild;
  		while(child){
  			node2.appendChild(cloneNode(doc,child,deep));
  			child = child.nextSibling;
  		}
  	}
  	return node2;
  }
  
  function __set__(object,key,value){
  	object[key] = value
  }
  //do dynamic
  try{
  	if(Object.defineProperty){
  		Object.defineProperty(LiveNodeList.prototype,'length',{
  			get:function(){
  				_updateLiveList(this);
  				return this.$$length;
  			}
  		});
  		Object.defineProperty(Node.prototype,'textContent',{
  			get:function(){
  				return getTextContent(this);
  			},
  			set:function(data){
  				switch(this.nodeType){
  				case ELEMENT_NODE:
  				case DOCUMENT_FRAGMENT_NODE:
  					while(this.firstChild){
  						this.removeChild(this.firstChild);
  					}
  					if(data || String(data)){
  						this.appendChild(this.ownerDocument.createTextNode(data));
  					}
  					break;
  				default:
  					//TODO:
  					this.data = data;
  					this.value = data;
  					this.nodeValue = data;
  				}
  			}
  		})
  		
  		function getTextContent(node){
  			switch(node.nodeType){
  			case ELEMENT_NODE:
  			case DOCUMENT_FRAGMENT_NODE:
  				var buf = [];
  				node = node.firstChild;
  				while(node){
  					if(node.nodeType!==7 && node.nodeType !==8){
  						buf.push(getTextContent(node));
  					}
  					node = node.nextSibling;
  				}
  				return buf.join('');
  			default:
  				return node.nodeValue;
  			}
  		}
  		__set__ = function(object,key,value){
  			//console.log(value)
  			object['$$'+key] = value
  		}
  	}
  }catch(e){//ie8
  }
  
  //if(typeof require == 'function'){
  	__webpack_unused_export__ = Node;
  	__webpack_unused_export__ = DOMException;
  	exports.DOMImplementation = DOMImplementation;
  	__webpack_unused_export__ = XMLSerializer;
  //}
  
  
  /***/ }),
  
  /***/ 3793:
  /***/ ((__unused_webpack_module, exports) => {
  
  exports.entityMap = {
         lt: '<',
         gt: '>',
         amp: '&',
         quot: '"',
         apos: "'",
         Agrave: "À",
         Aacute: "Á",
         Acirc: "Â",
         Atilde: "Ã",
         Auml: "Ä",
         Aring: "Å",
         AElig: "Æ",
         Ccedil: "Ç",
         Egrave: "È",
         Eacute: "É",
         Ecirc: "Ê",
         Euml: "Ë",
         Igrave: "Ì",
         Iacute: "Í",
         Icirc: "Î",
         Iuml: "Ï",
         ETH: "Ð",
         Ntilde: "Ñ",
         Ograve: "Ò",
         Oacute: "Ó",
         Ocirc: "Ô",
         Otilde: "Õ",
         Ouml: "Ö",
         Oslash: "Ø",
         Ugrave: "Ù",
         Uacute: "Ú",
         Ucirc: "Û",
         Uuml: "Ü",
         Yacute: "Ý",
         THORN: "Þ",
         szlig: "ß",
         agrave: "à",
         aacute: "á",
         acirc: "â",
         atilde: "ã",
         auml: "ä",
         aring: "å",
         aelig: "æ",
         ccedil: "ç",
         egrave: "è",
         eacute: "é",
         ecirc: "ê",
         euml: "ë",
         igrave: "ì",
         iacute: "í",
         icirc: "î",
         iuml: "ï",
         eth: "ð",
         ntilde: "ñ",
         ograve: "ò",
         oacute: "ó",
         ocirc: "ô",
         otilde: "õ",
         ouml: "ö",
         oslash: "ø",
         ugrave: "ù",
         uacute: "ú",
         ucirc: "û",
         uuml: "ü",
         yacute: "ý",
         thorn: "þ",
         yuml: "ÿ",
         nbsp: "\u00a0",
         iexcl: "¡",
         cent: "¢",
         pound: "£",
         curren: "¤",
         yen: "¥",
         brvbar: "¦",
         sect: "§",
         uml: "¨",
         copy: "©",
         ordf: "ª",
         laquo: "«",
         not: "¬",
         shy: "­­",
         reg: "®",
         macr: "¯",
         deg: "°",
         plusmn: "±",
         sup2: "²",
         sup3: "³",
         acute: "´",
         micro: "µ",
         para: "¶",
         middot: "·",
         cedil: "¸",
         sup1: "¹",
         ordm: "º",
         raquo: "»",
         frac14: "¼",
         frac12: "½",
         frac34: "¾",
         iquest: "¿",
         times: "×",
         divide: "÷",
         forall: "∀",
         part: "∂",
         exist: "∃",
         empty: "∅",
         nabla: "∇",
         isin: "∈",
         notin: "∉",
         ni: "∋",
         prod: "∏",
         sum: "∑",
         minus: "−",
         lowast: "∗",
         radic: "√",
         prop: "∝",
         infin: "∞",
         ang: "∠",
         and: "∧",
         or: "∨",
         cap: "∩",
         cup: "∪",
         'int': "∫",
         there4: "∴",
         sim: "∼",
         cong: "≅",
         asymp: "≈",
         ne: "≠",
         equiv: "≡",
         le: "≤",
         ge: "≥",
         sub: "⊂",
         sup: "⊃",
         nsub: "⊄",
         sube: "⊆",
         supe: "⊇",
         oplus: "⊕",
         otimes: "⊗",
         perp: "⊥",
         sdot: "⋅",
         Alpha: "Α",
         Beta: "Β",
         Gamma: "Γ",
         Delta: "Δ",
         Epsilon: "Ε",
         Zeta: "Ζ",
         Eta: "Η",
         Theta: "Θ",
         Iota: "Ι",
         Kappa: "Κ",
         Lambda: "Λ",
         Mu: "Μ",
         Nu: "Ν",
         Xi: "Ξ",
         Omicron: "Ο",
         Pi: "Π",
         Rho: "Ρ",
         Sigma: "Σ",
         Tau: "Τ",
         Upsilon: "Υ",
         Phi: "Φ",
         Chi: "Χ",
         Psi: "Ψ",
         Omega: "Ω",
         alpha: "α",
         beta: "β",
         gamma: "γ",
         delta: "δ",
         epsilon: "ε",
         zeta: "ζ",
         eta: "η",
         theta: "θ",
         iota: "ι",
         kappa: "κ",
         lambda: "λ",
         mu: "μ",
         nu: "ν",
         xi: "ξ",
         omicron: "ο",
         pi: "π",
         rho: "ρ",
         sigmaf: "ς",
         sigma: "σ",
         tau: "τ",
         upsilon: "υ",
         phi: "φ",
         chi: "χ",
         psi: "ψ",
         omega: "ω",
         thetasym: "ϑ",
         upsih: "ϒ",
         piv: "ϖ",
         OElig: "Œ",
         oelig: "œ",
         Scaron: "Š",
         scaron: "š",
         Yuml: "Ÿ",
         fnof: "ƒ",
         circ: "ˆ",
         tilde: "˜",
         ensp: " ",
         emsp: " ",
         thinsp: " ",
         zwnj: "‌",
         zwj: "‍",
         lrm: "‎",
         rlm: "‏",
         ndash: "–",
         mdash: "—",
         lsquo: "‘",
         rsquo: "’",
         sbquo: "‚",
         ldquo: "“",
         rdquo: "”",
         bdquo: "„",
         dagger: "†",
         Dagger: "‡",
         bull: "•",
         hellip: "…",
         permil: "‰",
         prime: "′",
         Prime: "″",
         lsaquo: "‹",
         rsaquo: "›",
         oline: "‾",
         euro: "€",
         trade: "™",
         larr: "←",
         uarr: "↑",
         rarr: "→",
         darr: "↓",
         harr: "↔",
         crarr: "↵",
         lceil: "⌈",
         rceil: "⌉",
         lfloor: "⌊",
         rfloor: "⌋",
         loz: "◊",
         spades: "♠",
         clubs: "♣",
         hearts: "♥",
         diams: "♦"
  };
  
  
  /***/ }),
  
  /***/ 4138:
  /***/ ((__unused_webpack_module, exports) => {
  
  //[4]   	NameStartChar	   ::=   	":" | [A-Z] | "_" | [a-z] | [#xC0-#xD6] | [#xD8-#xF6] | [#xF8-#x2FF] | [#x370-#x37D] | [#x37F-#x1FFF] | [#x200C-#x200D] | [#x2070-#x218F] | [#x2C00-#x2FEF] | [#x3001-#xD7FF] | [#xF900-#xFDCF] | [#xFDF0-#xFFFD] | [#x10000-#xEFFFF]
  //[4a]   	NameChar	   ::=   	NameStartChar | "-" | "." | [0-9] | #xB7 | [#x0300-#x036F] | [#x203F-#x2040]
  //[5]   	Name	   ::=   	NameStartChar (NameChar)*
  var nameStartChar = /[A-Z_a-z\xC0-\xD6\xD8-\xF6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]///\u10000-\uEFFFF
  var nameChar = new RegExp("[\\-\\.0-9"+nameStartChar.source.slice(1,-1)+"\\u00B7\\u0300-\\u036F\\u203F-\\u2040]");
  var tagNamePattern = new RegExp('^'+nameStartChar.source+nameChar.source+'*(?:\:'+nameStartChar.source+nameChar.source+'*)?$');
  //var tagNamePattern = /^[a-zA-Z_][\w\-\.]*(?:\:[a-zA-Z_][\w\-\.]*)?$/
  //var handlers = 'resolveEntity,getExternalSubset,characters,endDocument,endElement,endPrefixMapping,ignorableWhitespace,processingInstruction,setDocumentLocator,skippedEntity,startDocument,startElement,startPrefixMapping,notationDecl,unparsedEntityDecl,error,fatalError,warning,attributeDecl,elementDecl,externalEntityDecl,internalEntityDecl,comment,endCDATA,endDTD,endEntity,startCDATA,startDTD,startEntity'.split(',')
  
  //S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
  //S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
  var S_TAG = 0;//tag name offerring
  var S_ATTR = 1;//attr name offerring 
  var S_ATTR_SPACE=2;//attr name end and space offer
  var S_EQ = 3;//=space?
  var S_ATTR_NOQUOT_VALUE = 4;//attr value(no quot value only)
  var S_ATTR_END = 5;//attr value end and no space(quot end)
  var S_TAG_SPACE = 6;//(attr value end || tag end ) && (space offer)
  var S_TAG_CLOSE = 7;//closed el<el />
  
  /**
   * Creates an error that will not be caught by XMLReader aka the SAX parser.
   *
   * @param {string} message
   * @param {any?} locator Optional, can provide details about the location in the source
   * @constructor
   */
  function ParseError(message, locator) {
  	this.message = message
  	this.locator = locator
  	if(Error.captureStackTrace) Error.captureStackTrace(this, ParseError);
  }
  ParseError.prototype = new Error();
  ParseError.prototype.name = ParseError.name
  
  function XMLReader(){
  	
  }
  
  XMLReader.prototype = {
  	parse:function(source,defaultNSMap,entityMap){
  		var domBuilder = this.domBuilder;
  		domBuilder.startDocument();
  		_copy(defaultNSMap ,defaultNSMap = {})
  		parse(source,defaultNSMap,entityMap,
  				domBuilder,this.errorHandler);
  		domBuilder.endDocument();
  	}
  }
  function parse(source,defaultNSMapCopy,entityMap,domBuilder,errorHandler){
  	function fixedFromCharCode(code) {
  		// String.prototype.fromCharCode does not supports
  		// > 2 bytes unicode chars directly
  		if (code > 0xffff) {
  			code -= 0x10000;
  			var surrogate1 = 0xd800 + (code >> 10)
  				, surrogate2 = 0xdc00 + (code & 0x3ff);
  
  			return String.fromCharCode(surrogate1, surrogate2);
  		} else {
  			return String.fromCharCode(code);
  		}
  	}
  	function entityReplacer(a){
  		var k = a.slice(1,-1);
  		if(k in entityMap){
  			return entityMap[k]; 
  		}else if(k.charAt(0) === '#'){
  			return fixedFromCharCode(parseInt(k.substr(1).replace('x','0x')))
  		}else{
  			errorHandler.error('entity not found:'+a);
  			return a;
  		}
  	}
  	function appendText(end){//has some bugs
  		if(end>start){
  			var xt = source.substring(start,end).replace(/&#?\w+;/g,entityReplacer);
  			locator&&position(start);
  			domBuilder.characters(xt,0,end-start);
  			start = end
  		}
  	}
  	function position(p,m){
  		while(p>=lineEnd && (m = linePattern.exec(source))){
  			lineStart = m.index;
  			lineEnd = lineStart + m[0].length;
  			locator.lineNumber++;
  			//console.log('line++:',locator,startPos,endPos)
  		}
  		locator.columnNumber = p-lineStart+1;
  	}
  	var lineStart = 0;
  	var lineEnd = 0;
  	var linePattern = /.*(?:\r\n?|\n)|.*$/g
  	var locator = domBuilder.locator;
  	
  	var parseStack = [{currentNSMap:defaultNSMapCopy}]
  	var closeMap = {};
  	var start = 0;
  	while(true){
  		try{
  			var tagStart = source.indexOf('<',start);
  			if(tagStart<0){
  				if(!source.substr(start).match(/^\s*$/)){
  					var doc = domBuilder.doc;
  	    			var text = doc.createTextNode(source.substr(start));
  	    			doc.appendChild(text);
  	    			domBuilder.currentElement = text;
  				}
  				return;
  			}
  			if(tagStart>start){
  				appendText(tagStart);
  			}
  			switch(source.charAt(tagStart+1)){
  			case '/':
  				var end = source.indexOf('>',tagStart+3);
  				var tagName = source.substring(tagStart+2,end);
  				var config = parseStack.pop();
  				if(end<0){
  					
  	        		tagName = source.substring(tagStart+2).replace(/[\s<].*/,'');
  	        		//console.error('#@@@@@@'+tagName)
  	        		errorHandler.error("end tag name: "+tagName+' is not complete:'+config.tagName);
  	        		end = tagStart+1+tagName.length;
  	        	}else if(tagName.match(/\s</)){
  	        		tagName = tagName.replace(/[\s<].*/,'');
  	        		errorHandler.error("end tag name: "+tagName+' maybe not complete');
  	        		end = tagStart+1+tagName.length;
  				}
  				//console.error(parseStack.length,parseStack)
  				//console.error(config);
  				var localNSMap = config.localNSMap;
  				var endMatch = config.tagName == tagName;
  				var endIgnoreCaseMach = endMatch || config.tagName&&config.tagName.toLowerCase() == tagName.toLowerCase()
  		        if(endIgnoreCaseMach){
  		        	domBuilder.endElement(config.uri,config.localName,tagName);
  					if(localNSMap){
  						for(var prefix in localNSMap){
  							domBuilder.endPrefixMapping(prefix) ;
  						}
  					}
  					if(!endMatch){
  		            	errorHandler.fatalError("end tag name: "+tagName+' is not match the current start tagName:'+config.tagName ); // No known test case
  					}
  		        }else{
  		        	parseStack.push(config)
  		        }
  				
  				end++;
  				break;
  				// end elment
  			case '?':// <?...?>
  				locator&&position(tagStart);
  				end = parseInstruction(source,tagStart,domBuilder);
  				break;
  			case '!':// <!doctype,<![CDATA,<!--
  				locator&&position(tagStart);
  				end = parseDCC(source,tagStart,domBuilder,errorHandler);
  				break;
  			default:
  				locator&&position(tagStart);
  				var el = new ElementAttributes();
  				var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
  				//elStartEnd
  				var end = parseElementStartPart(source,tagStart,el,currentNSMap,entityReplacer,errorHandler);
  				var len = el.length;
  				
  				
  				if(!el.closed && fixSelfClosed(source,end,el.tagName,closeMap)){
  					el.closed = true;
  					if(!entityMap.nbsp){
  						errorHandler.warning('unclosed xml attribute');
  					}
  				}
  				if(locator && len){
  					var locator2 = copyLocator(locator,{});
  					//try{//attribute position fixed
  					for(var i = 0;i<len;i++){
  						var a = el[i];
  						position(a.offset);
  						a.locator = copyLocator(locator,{});
  					}
  					//}catch(e){console.error('@@@@@'+e)}
  					domBuilder.locator = locator2
  					if(appendElement(el,domBuilder,currentNSMap)){
  						parseStack.push(el)
  					}
  					domBuilder.locator = locator;
  				}else{
  					if(appendElement(el,domBuilder,currentNSMap)){
  						parseStack.push(el)
  					}
  				}
  				
  				
  				
  				if(el.uri === 'http://www.w3.org/1999/xhtml' && !el.closed){
  					end = parseHtmlSpecialContent(source,end,el.tagName,entityReplacer,domBuilder)
  				}else{
  					end++;
  				}
  			}
  		}catch(e){
  			if (e instanceof ParseError) {
  				throw e;
  			}
  			errorHandler.error('element parse error: '+e)
  			end = -1;
  		}
  		if(end>start){
  			start = end;
  		}else{
  			//TODO: 这里有可能sax回退，有位置错误风险
  			appendText(Math.max(tagStart,start)+1);
  		}
  	}
  }
  function copyLocator(f,t){
  	t.lineNumber = f.lineNumber;
  	t.columnNumber = f.columnNumber;
  	return t;
  }
  
  /**
   * @see #appendElement(source,elStartEnd,el,selfClosed,entityReplacer,domBuilder,parseStack);
   * @return end of the elementStartPart(end of elementEndPart for selfClosed el)
   */
  function parseElementStartPart(source,start,el,currentNSMap,entityReplacer,errorHandler){
  
  	/**
  	 * @param {string} qname
  	 * @param {string} value
  	 * @param {number} startIndex
  	 */
  	function addAttribute(qname, value, startIndex) {
  		if (qname in el.attributeNames) errorHandler.fatalError('Attribute ' + qname + ' redefined')
  		el.addValue(qname, value, startIndex)
  	}
  	var attrName;
  	var value;
  	var p = ++start;
  	var s = S_TAG;//status
  	while(true){
  		var c = source.charAt(p);
  		switch(c){
  		case '=':
  			if(s === S_ATTR){//attrName
  				attrName = source.slice(start,p);
  				s = S_EQ;
  			}else if(s === S_ATTR_SPACE){
  				s = S_EQ;
  			}else{
  				//fatalError: equal must after attrName or space after attrName
  				throw new Error('attribute equal must after attrName'); // No known test case
  			}
  			break;
  		case '\'':
  		case '"':
  			if(s === S_EQ || s === S_ATTR //|| s == S_ATTR_SPACE
  				){//equal
  				if(s === S_ATTR){
  					errorHandler.warning('attribute value must after "="')
  					attrName = source.slice(start,p)
  				}
  				start = p+1;
  				p = source.indexOf(c,start)
  				if(p>0){
  					value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  					addAttribute(attrName, value, start-1);
  					s = S_ATTR_END;
  				}else{
  					//fatalError: no end quot match
  					throw new Error('attribute value no end \''+c+'\' match');
  				}
  			}else if(s == S_ATTR_NOQUOT_VALUE){
  				value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  				//console.log(attrName,value,start,p)
  				addAttribute(attrName, value, start);
  				//console.dir(el)
  				errorHandler.warning('attribute "'+attrName+'" missed start quot('+c+')!!');
  				start = p+1;
  				s = S_ATTR_END
  			}else{
  				//fatalError: no equal before
  				throw new Error('attribute value must after "="'); // No known test case
  			}
  			break;
  		case '/':
  			switch(s){
  			case S_TAG:
  				el.setTagName(source.slice(start,p));
  			case S_ATTR_END:
  			case S_TAG_SPACE:
  			case S_TAG_CLOSE:
  				s =S_TAG_CLOSE;
  				el.closed = true;
  			case S_ATTR_NOQUOT_VALUE:
  			case S_ATTR:
  			case S_ATTR_SPACE:
  				break;
  			//case S_EQ:
  			default:
  				throw new Error("attribute invalid close char('/')") // No known test case
  			}
  			break;
  		case ''://end document
  			errorHandler.error('unexpected end of input');
  			if(s == S_TAG){
  				el.setTagName(source.slice(start,p));
  			}
  			return p;
  		case '>':
  			switch(s){
  			case S_TAG:
  				el.setTagName(source.slice(start,p));
  			case S_ATTR_END:
  			case S_TAG_SPACE:
  			case S_TAG_CLOSE:
  				break;//normal
  			case S_ATTR_NOQUOT_VALUE://Compatible state
  			case S_ATTR:
  				value = source.slice(start,p);
  				if(value.slice(-1) === '/'){
  					el.closed  = true;
  					value = value.slice(0,-1)
  				}
  			case S_ATTR_SPACE:
  				if(s === S_ATTR_SPACE){
  					value = attrName;
  				}
  				if(s == S_ATTR_NOQUOT_VALUE){
  					errorHandler.warning('attribute "'+value+'" missed quot(")!');
  					addAttribute(attrName, value.replace(/&#?\w+;/g,entityReplacer), start)
  				}else{
  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !value.match(/^(?:disabled|checked|selected)$/i)){
  						errorHandler.warning('attribute "'+value+'" missed value!! "'+value+'" instead!!')
  					}
  					addAttribute(value, value, start)
  				}
  				break;
  			case S_EQ:
  				throw new Error('attribute value missed!!');
  			}
  //			console.log(tagName,tagNamePattern,tagNamePattern.test(tagName))
  			return p;
  		/*xml space '\x20' | #x9 | #xD | #xA; */
  		case '\u0080':
  			c = ' ';
  		default:
  			if(c<= ' '){//space
  				switch(s){
  				case S_TAG:
  					el.setTagName(source.slice(start,p));//tagName
  					s = S_TAG_SPACE;
  					break;
  				case S_ATTR:
  					attrName = source.slice(start,p)
  					s = S_ATTR_SPACE;
  					break;
  				case S_ATTR_NOQUOT_VALUE:
  					var value = source.slice(start,p).replace(/&#?\w+;/g,entityReplacer);
  					errorHandler.warning('attribute "'+value+'" missed quot(")!!');
  					addAttribute(attrName, value, start)
  				case S_ATTR_END:
  					s = S_TAG_SPACE;
  					break;
  				//case S_TAG_SPACE:
  				//case S_EQ:
  				//case S_ATTR_SPACE:
  				//	void();break;
  				//case S_TAG_CLOSE:
  					//ignore warning
  				}
  			}else{//not space
  //S_TAG,	S_ATTR,	S_EQ,	S_ATTR_NOQUOT_VALUE
  //S_ATTR_SPACE,	S_ATTR_END,	S_TAG_SPACE, S_TAG_CLOSE
  				switch(s){
  				//case S_TAG:void();break;
  				//case S_ATTR:void();break;
  				//case S_ATTR_NOQUOT_VALUE:void();break;
  				case S_ATTR_SPACE:
  					var tagName =  el.tagName;
  					if(currentNSMap[''] !== 'http://www.w3.org/1999/xhtml' || !attrName.match(/^(?:disabled|checked|selected)$/i)){
  						errorHandler.warning('attribute "'+attrName+'" missed value!! "'+attrName+'" instead2!!')
  					}
  					addAttribute(attrName, attrName, start);
  					start = p;
  					s = S_ATTR;
  					break;
  				case S_ATTR_END:
  					errorHandler.warning('attribute space is required"'+attrName+'"!!')
  				case S_TAG_SPACE:
  					s = S_ATTR;
  					start = p;
  					break;
  				case S_EQ:
  					s = S_ATTR_NOQUOT_VALUE;
  					start = p;
  					break;
  				case S_TAG_CLOSE:
  					throw new Error("elements closed character '/' and '>' must be connected to");
  				}
  			}
  		}//end outer switch
  		//console.log('p++',p)
  		p++;
  	}
  }
  /**
   * @return true if has new namespace define
   */
  function appendElement(el,domBuilder,currentNSMap){
  	var tagName = el.tagName;
  	var localNSMap = null;
  	//var currentNSMap = parseStack[parseStack.length-1].currentNSMap;
  	var i = el.length;
  	while(i--){
  		var a = el[i];
  		var qName = a.qName;
  		var value = a.value;
  		var nsp = qName.indexOf(':');
  		if(nsp>0){
  			var prefix = a.prefix = qName.slice(0,nsp);
  			var localName = qName.slice(nsp+1);
  			var nsPrefix = prefix === 'xmlns' && localName
  		}else{
  			localName = qName;
  			prefix = null
  			nsPrefix = qName === 'xmlns' && ''
  		}
  		//can not set prefix,because prefix !== ''
  		a.localName = localName ;
  		//prefix == null for no ns prefix attribute 
  		if(nsPrefix !== false){//hack!!
  			if(localNSMap == null){
  				localNSMap = {}
  				//console.log(currentNSMap,0)
  				_copy(currentNSMap,currentNSMap={})
  				//console.log(currentNSMap,1)
  			}
  			currentNSMap[nsPrefix] = localNSMap[nsPrefix] = value;
  			a.uri = 'http://www.w3.org/2000/xmlns/'
  			domBuilder.startPrefixMapping(nsPrefix, value) 
  		}
  	}
  	var i = el.length;
  	while(i--){
  		a = el[i];
  		var prefix = a.prefix;
  		if(prefix){//no prefix attribute has no namespace
  			if(prefix === 'xml'){
  				a.uri = 'http://www.w3.org/XML/1998/namespace';
  			}if(prefix !== 'xmlns'){
  				a.uri = currentNSMap[prefix || '']
  				
  				//{console.log('###'+a.qName,domBuilder.locator.systemId+'',currentNSMap,a.uri)}
  			}
  		}
  	}
  	var nsp = tagName.indexOf(':');
  	if(nsp>0){
  		prefix = el.prefix = tagName.slice(0,nsp);
  		localName = el.localName = tagName.slice(nsp+1);
  	}else{
  		prefix = null;//important!!
  		localName = el.localName = tagName;
  	}
  	//no prefix element has default namespace
  	var ns = el.uri = currentNSMap[prefix || ''];
  	domBuilder.startElement(ns,localName,tagName,el);
  	//endPrefixMapping and startPrefixMapping have not any help for dom builder
  	//localNSMap = null
  	if(el.closed){
  		domBuilder.endElement(ns,localName,tagName);
  		if(localNSMap){
  			for(prefix in localNSMap){
  				domBuilder.endPrefixMapping(prefix) 
  			}
  		}
  	}else{
  		el.currentNSMap = currentNSMap;
  		el.localNSMap = localNSMap;
  		//parseStack.push(el);
  		return true;
  	}
  }
  function parseHtmlSpecialContent(source,elStartEnd,tagName,entityReplacer,domBuilder){
  	if(/^(?:script|textarea)$/i.test(tagName)){
  		var elEndStart =  source.indexOf('</'+tagName+'>',elStartEnd);
  		var text = source.substring(elStartEnd+1,elEndStart);
  		if(/[&<]/.test(text)){
  			if(/^script$/i.test(tagName)){
  				//if(!/\]\]>/.test(text)){
  					//lexHandler.startCDATA();
  					domBuilder.characters(text,0,text.length);
  					//lexHandler.endCDATA();
  					return elEndStart;
  				//}
  			}//}else{//text area
  				text = text.replace(/&#?\w+;/g,entityReplacer);
  				domBuilder.characters(text,0,text.length);
  				return elEndStart;
  			//}
  			
  		}
  	}
  	return elStartEnd+1;
  }
  function fixSelfClosed(source,elStartEnd,tagName,closeMap){
  	//if(tagName in closeMap){
  	var pos = closeMap[tagName];
  	if(pos == null){
  		//console.log(tagName)
  		pos =  source.lastIndexOf('</'+tagName+'>')
  		if(pos<elStartEnd){//忘记闭合
  			pos = source.lastIndexOf('</'+tagName)
  		}
  		closeMap[tagName] =pos
  	}
  	return pos<elStartEnd;
  	//} 
  }
  function _copy(source,target){
  	for(var n in source){target[n] = source[n]}
  }
  function parseDCC(source,start,domBuilder,errorHandler){//sure start with '<!'
  	var next= source.charAt(start+2)
  	switch(next){
  	case '-':
  		if(source.charAt(start + 3) === '-'){
  			var end = source.indexOf('-->',start+4);
  			//append comment source.substring(4,end)//<!--
  			if(end>start){
  				domBuilder.comment(source,start+4,end-start-4);
  				return end+3;
  			}else{
  				errorHandler.error("Unclosed comment");
  				return -1;
  			}
  		}else{
  			//error
  			return -1;
  		}
  	default:
  		if(source.substr(start+3,6) == 'CDATA['){
  			var end = source.indexOf(']]>',start+9);
  			domBuilder.startCDATA();
  			domBuilder.characters(source,start+9,end-start-9);
  			domBuilder.endCDATA() 
  			return end+3;
  		}
  		//<!DOCTYPE
  		//startDTD(java.lang.String name, java.lang.String publicId, java.lang.String systemId) 
  		var matchs = split(source,start);
  		var len = matchs.length;
  		if(len>1 && /!doctype/i.test(matchs[0][0])){
  			var name = matchs[1][0];
  			var pubid = false;
  			var sysid = false;
  			if(len>3){
  				if(/^public$/i.test(matchs[2][0])){
  					pubid = matchs[3][0];
  					sysid = len>4 && matchs[4][0];
  				}else if(/^system$/i.test(matchs[2][0])){
  					sysid = matchs[3][0];
  				}
  			}
  			var lastMatch = matchs[len-1]
  			domBuilder.startDTD(name, pubid, sysid);
  			domBuilder.endDTD();
  			
  			return lastMatch.index+lastMatch[0].length
  		}
  	}
  	return -1;
  }
  
  
  
  function parseInstruction(source,start,domBuilder){
  	var end = source.indexOf('?>',start);
  	if(end){
  		var match = source.substring(start,end).match(/^<\?(\S*)\s*([\s\S]*?)\s*$/);
  		if(match){
  			var len = match[0].length;
  			domBuilder.processingInstruction(match[1], match[2]) ;
  			return end+2;
  		}else{//error
  			return -1;
  		}
  	}
  	return -1;
  }
  
  function ElementAttributes(){
  	this.attributeNames = {}
  }
  ElementAttributes.prototype = {
  	setTagName:function(tagName){
  		if(!tagNamePattern.test(tagName)){
  			throw new Error('invalid tagName:'+tagName)
  		}
  		this.tagName = tagName
  	},
  	addValue:function(qName, value, offset) {
  		if(!tagNamePattern.test(qName)){
  			throw new Error('invalid attribute:'+qName)
  		}
  		this.attributeNames[qName] = this.length;
  		this[this.length++] = {qName:qName,value:value,offset:offset}
  	},
  	length:0,
  	getLocalName:function(i){return this[i].localName},
  	getLocator:function(i){return this[i].locator},
  	getQName:function(i){return this[i].qName},
  	getURI:function(i){return this[i].uri},
  	getValue:function(i){return this[i].value}
  //	,getIndex:function(uri, localName)){
  //		if(localName){
  //			
  //		}else{
  //			var qName = uri
  //		}
  //	},
  //	getValue:function(){return this.getValue(this.getIndex.apply(this,arguments))},
  //	getType:function(uri,localName){}
  //	getType:function(i){},
  }
  
  
  
  function split(source,start){
  	var match;
  	var buf = [];
  	var reg = /'[^']+'|"[^"]+"|[^\s<>\/=]+=?|(\/?\s*>|<)/g;
  	reg.lastIndex = start;
  	reg.exec(source);//skip <
  	while(match = reg.exec(source)){
  		buf.push(match);
  		if(match[1])return buf;
  	}
  }
  
  exports.XMLReader = XMLReader;
  exports.ParseError = ParseError;
  
  
  /***/ }),
  
  /***/ 9119:
  /***/ ((__unused_webpack_module, exports, __nccwpck_require__) => {
  
  var fs = __nccwpck_require__(5747);
  var zlib = __nccwpck_require__(8761);
  var fd_slicer = __nccwpck_require__(5214);
  var crc32 = __nccwpck_require__(6542);
  var util = __nccwpck_require__(1669);
  var EventEmitter = __nccwpck_require__(8614).EventEmitter;
  var Transform = __nccwpck_require__(2413).Transform;
  var PassThrough = __nccwpck_require__(2413).PassThrough;
  var Writable = __nccwpck_require__(2413).Writable;
  
  exports.open = open;
  exports.fromFd = fromFd;
  exports.fromBuffer = fromBuffer;
  exports.fromRandomAccessReader = fromRandomAccessReader;
  exports.dosDateTimeToDate = dosDateTimeToDate;
  exports.validateFileName = validateFileName;
  exports.ZipFile = ZipFile;
  exports.Entry = Entry;
  exports.RandomAccessReader = RandomAccessReader;
  
  function open(path, options, callback) {
    if (typeof options === "function") {
      callback = options;
      options = null;
    }
    if (options == null) options = {};
    if (options.autoClose == null) options.autoClose = true;
    if (options.lazyEntries == null) options.lazyEntries = false;
    if (options.decodeStrings == null) options.decodeStrings = true;
    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
    if (options.strictFileNames == null) options.strictFileNames = false;
    if (callback == null) callback = defaultCallback;
    fs.open(path, "r", function(err, fd) {
      if (err) return callback(err);
      fromFd(fd, options, function(err, zipfile) {
        if (err) fs.close(fd, defaultCallback);
        callback(err, zipfile);
      });
    });
  }
  
  function fromFd(fd, options, callback) {
    if (typeof options === "function") {
      callback = options;
      options = null;
    }
    if (options == null) options = {};
    if (options.autoClose == null) options.autoClose = false;
    if (options.lazyEntries == null) options.lazyEntries = false;
    if (options.decodeStrings == null) options.decodeStrings = true;
    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
    if (options.strictFileNames == null) options.strictFileNames = false;
    if (callback == null) callback = defaultCallback;
    fs.fstat(fd, function(err, stats) {
      if (err) return callback(err);
      var reader = fd_slicer.createFromFd(fd, {autoClose: true});
      fromRandomAccessReader(reader, stats.size, options, callback);
    });
  }
  
  function fromBuffer(buffer, options, callback) {
    if (typeof options === "function") {
      callback = options;
      options = null;
    }
    if (options == null) options = {};
    options.autoClose = false;
    if (options.lazyEntries == null) options.lazyEntries = false;
    if (options.decodeStrings == null) options.decodeStrings = true;
    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
    if (options.strictFileNames == null) options.strictFileNames = false;
    // limit the max chunk size. see https://github.com/thejoshwolfe/yauzl/issues/87
    var reader = fd_slicer.createFromBuffer(buffer, {maxChunkSize: 0x10000});
    fromRandomAccessReader(reader, buffer.length, options, callback);
  }
  
  function fromRandomAccessReader(reader, totalSize, options, callback) {
    if (typeof options === "function") {
      callback = options;
      options = null;
    }
    if (options == null) options = {};
    if (options.autoClose == null) options.autoClose = true;
    if (options.lazyEntries == null) options.lazyEntries = false;
    if (options.decodeStrings == null) options.decodeStrings = true;
    var decodeStrings = !!options.decodeStrings;
    if (options.validateEntrySizes == null) options.validateEntrySizes = true;
    if (options.strictFileNames == null) options.strictFileNames = false;
    if (callback == null) callback = defaultCallback;
    if (typeof totalSize !== "number") throw new Error("expected totalSize parameter to be a number");
    if (totalSize > Number.MAX_SAFE_INTEGER) {
      throw new Error("zip file too large. only file sizes up to 2^52 are supported due to JavaScript's Number type being an IEEE 754 double.");
    }
  
    // the matching unref() call is in zipfile.close()
    reader.ref();
  
    // eocdr means End of Central Directory Record.
    // search backwards for the eocdr signature.
    // the last field of the eocdr is a variable-length comment.
    // the comment size is encoded in a 2-byte field in the eocdr, which we can't find without trudging backwards through the comment to find it.
    // as a consequence of this design decision, it's possible to have ambiguous zip file metadata if a coherent eocdr was in the comment.
    // we search backwards for a eocdr signature, and hope that whoever made the zip file was smart enough to forbid the eocdr signature in the comment.
    var eocdrWithoutCommentSize = 22;
    var maxCommentSize = 0xffff; // 2-byte size
    var bufferSize = Math.min(eocdrWithoutCommentSize + maxCommentSize, totalSize);
    var buffer = newBuffer(bufferSize);
    var bufferReadStart = totalSize - buffer.length;
    readAndAssertNoEof(reader, buffer, 0, bufferSize, bufferReadStart, function(err) {
      if (err) return callback(err);
      for (var i = bufferSize - eocdrWithoutCommentSize; i >= 0; i -= 1) {
        if (buffer.readUInt32LE(i) !== 0x06054b50) continue;
        // found eocdr
        var eocdrBuffer = buffer.slice(i);
  
        // 0 - End of central directory signature = 0x06054b50
        // 4 - Number of this disk
        var diskNumber = eocdrBuffer.readUInt16LE(4);
        if (diskNumber !== 0) {
          return callback(new Error("multi-disk zip files are not supported: found disk number: " + diskNumber));
        }
        // 6 - Disk where central directory starts
        // 8 - Number of central directory records on this disk
        // 10 - Total number of central directory records
        var entryCount = eocdrBuffer.readUInt16LE(10);
        // 12 - Size of central directory (bytes)
        // 16 - Offset of start of central directory, relative to start of archive
        var centralDirectoryOffset = eocdrBuffer.readUInt32LE(16);
        // 20 - Comment length
        var commentLength = eocdrBuffer.readUInt16LE(20);
        var expectedCommentLength = eocdrBuffer.length - eocdrWithoutCommentSize;
        if (commentLength !== expectedCommentLength) {
          return callback(new Error("invalid comment length. expected: " + expectedCommentLength + ". found: " + commentLength));
        }
        // 22 - Comment
        // the encoding is always cp437.
        var comment = decodeStrings ? decodeBuffer(eocdrBuffer, 22, eocdrBuffer.length, false)
                                    : eocdrBuffer.slice(22);
  
        if (!(entryCount === 0xffff || centralDirectoryOffset === 0xffffffff)) {
          return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
        }
  
        // ZIP64 format
  
        // ZIP64 Zip64 end of central directory locator
        var zip64EocdlBuffer = newBuffer(20);
        var zip64EocdlOffset = bufferReadStart + i - zip64EocdlBuffer.length;
        readAndAssertNoEof(reader, zip64EocdlBuffer, 0, zip64EocdlBuffer.length, zip64EocdlOffset, function(err) {
          if (err) return callback(err);
  
          // 0 - zip64 end of central dir locator signature = 0x07064b50
          if (zip64EocdlBuffer.readUInt32LE(0) !== 0x07064b50) {
            return callback(new Error("invalid zip64 end of central directory locator signature"));
          }
          // 4 - number of the disk with the start of the zip64 end of central directory
          // 8 - relative offset of the zip64 end of central directory record
          var zip64EocdrOffset = readUInt64LE(zip64EocdlBuffer, 8);
          // 16 - total number of disks
  
          // ZIP64 end of central directory record
          var zip64EocdrBuffer = newBuffer(56);
          readAndAssertNoEof(reader, zip64EocdrBuffer, 0, zip64EocdrBuffer.length, zip64EocdrOffset, function(err) {
            if (err) return callback(err);
  
            // 0 - zip64 end of central dir signature                           4 bytes  (0x06064b50)
            if (zip64EocdrBuffer.readUInt32LE(0) !== 0x06064b50) {
              return callback(new Error("invalid zip64 end of central directory record signature"));
            }
            // 4 - size of zip64 end of central directory record                8 bytes
            // 12 - version made by                                             2 bytes
            // 14 - version needed to extract                                   2 bytes
            // 16 - number of this disk                                         4 bytes
            // 20 - number of the disk with the start of the central directory  4 bytes
            // 24 - total number of entries in the central directory on this disk         8 bytes
            // 32 - total number of entries in the central directory            8 bytes
            entryCount = readUInt64LE(zip64EocdrBuffer, 32);
            // 40 - size of the central directory                               8 bytes
            // 48 - offset of start of central directory with respect to the starting disk number     8 bytes
            centralDirectoryOffset = readUInt64LE(zip64EocdrBuffer, 48);
            // 56 - zip64 extensible data sector                                (variable size)
            return callback(null, new ZipFile(reader, centralDirectoryOffset, totalSize, entryCount, comment, options.autoClose, options.lazyEntries, decodeStrings, options.validateEntrySizes, options.strictFileNames));
          });
        });
        return;
      }
      callback(new Error("end of central directory record signature not found"));
    });
  }
  
  util.inherits(ZipFile, EventEmitter);
  function ZipFile(reader, centralDirectoryOffset, fileSize, entryCount, comment, autoClose, lazyEntries, decodeStrings, validateEntrySizes, strictFileNames) {
    var self = this;
    EventEmitter.call(self);
    self.reader = reader;
    // forward close events
    self.reader.on("error", function(err) {
      // error closing the fd
      emitError(self, err);
    });
    self.reader.once("close", function() {
      self.emit("close");
    });
    self.readEntryCursor = centralDirectoryOffset;
    self.fileSize = fileSize;
    self.entryCount = entryCount;
    self.comment = comment;
    self.entriesRead = 0;
    self.autoClose = !!autoClose;
    self.lazyEntries = !!lazyEntries;
    self.decodeStrings = !!decodeStrings;
    self.validateEntrySizes = !!validateEntrySizes;
    self.strictFileNames = !!strictFileNames;
    self.isOpen = true;
    self.emittedError = false;
  
    if (!self.lazyEntries) self._readEntry();
  }
  ZipFile.prototype.close = function() {
    if (!this.isOpen) return;
    this.isOpen = false;
    this.reader.unref();
  };
  
  function emitErrorAndAutoClose(self, err) {
    if (self.autoClose) self.close();
    emitError(self, err);
  }
  function emitError(self, err) {
    if (self.emittedError) return;
    self.emittedError = true;
    self.emit("error", err);
  }
  
  ZipFile.prototype.readEntry = function() {
    if (!this.lazyEntries) throw new Error("readEntry() called without lazyEntries:true");
    this._readEntry();
  };
  ZipFile.prototype._readEntry = function() {
    var self = this;
    if (self.entryCount === self.entriesRead) {
      // done with metadata
      setImmediate(function() {
        if (self.autoClose) self.close();
        if (self.emittedError) return;
        self.emit("end");
      });
      return;
    }
    if (self.emittedError) return;
    var buffer = newBuffer(46);
    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
      if (err) return emitErrorAndAutoClose(self, err);
      if (self.emittedError) return;
      var entry = new Entry();
      // 0 - Central directory file header signature
      var signature = buffer.readUInt32LE(0);
      if (signature !== 0x02014b50) return emitErrorAndAutoClose(self, new Error("invalid central directory file header signature: 0x" + signature.toString(16)));
      // 4 - Version made by
      entry.versionMadeBy = buffer.readUInt16LE(4);
      // 6 - Version needed to extract (minimum)
      entry.versionNeededToExtract = buffer.readUInt16LE(6);
      // 8 - General purpose bit flag
      entry.generalPurposeBitFlag = buffer.readUInt16LE(8);
      // 10 - Compression method
      entry.compressionMethod = buffer.readUInt16LE(10);
      // 12 - File last modification time
      entry.lastModFileTime = buffer.readUInt16LE(12);
      // 14 - File last modification date
      entry.lastModFileDate = buffer.readUInt16LE(14);
      // 16 - CRC-32
      entry.crc32 = buffer.readUInt32LE(16);
      // 20 - Compressed size
      entry.compressedSize = buffer.readUInt32LE(20);
      // 24 - Uncompressed size
      entry.uncompressedSize = buffer.readUInt32LE(24);
      // 28 - File name length (n)
      entry.fileNameLength = buffer.readUInt16LE(28);
      // 30 - Extra field length (m)
      entry.extraFieldLength = buffer.readUInt16LE(30);
      // 32 - File comment length (k)
      entry.fileCommentLength = buffer.readUInt16LE(32);
      // 34 - Disk number where file starts
      // 36 - Internal file attributes
      entry.internalFileAttributes = buffer.readUInt16LE(36);
      // 38 - External file attributes
      entry.externalFileAttributes = buffer.readUInt32LE(38);
      // 42 - Relative offset of local file header
      entry.relativeOffsetOfLocalHeader = buffer.readUInt32LE(42);
  
      if (entry.generalPurposeBitFlag & 0x40) return emitErrorAndAutoClose(self, new Error("strong encryption is not supported"));
  
      self.readEntryCursor += 46;
  
      buffer = newBuffer(entry.fileNameLength + entry.extraFieldLength + entry.fileCommentLength);
      readAndAssertNoEof(self.reader, buffer, 0, buffer.length, self.readEntryCursor, function(err) {
        if (err) return emitErrorAndAutoClose(self, err);
        if (self.emittedError) return;
        // 46 - File name
        var isUtf8 = (entry.generalPurposeBitFlag & 0x800) !== 0;
        entry.fileName = self.decodeStrings ? decodeBuffer(buffer, 0, entry.fileNameLength, isUtf8)
                                            : buffer.slice(0, entry.fileNameLength);
  
        // 46+n - Extra field
        var fileCommentStart = entry.fileNameLength + entry.extraFieldLength;
        var extraFieldBuffer = buffer.slice(entry.fileNameLength, fileCommentStart);
        entry.extraFields = [];
        var i = 0;
        while (i < extraFieldBuffer.length - 3) {
          var headerId = extraFieldBuffer.readUInt16LE(i + 0);
          var dataSize = extraFieldBuffer.readUInt16LE(i + 2);
          var dataStart = i + 4;
          var dataEnd = dataStart + dataSize;
          if (dataEnd > extraFieldBuffer.length) return emitErrorAndAutoClose(self, new Error("extra field length exceeds extra field buffer size"));
          var dataBuffer = newBuffer(dataSize);
          extraFieldBuffer.copy(dataBuffer, 0, dataStart, dataEnd);
          entry.extraFields.push({
            id: headerId,
            data: dataBuffer,
          });
          i = dataEnd;
        }
  
        // 46+n+m - File comment
        entry.fileComment = self.decodeStrings ? decodeBuffer(buffer, fileCommentStart, fileCommentStart + entry.fileCommentLength, isUtf8)
                                               : buffer.slice(fileCommentStart, fileCommentStart + entry.fileCommentLength);
        // compatibility hack for https://github.com/thejoshwolfe/yauzl/issues/47
        entry.comment = entry.fileComment;
  
        self.readEntryCursor += buffer.length;
        self.entriesRead += 1;
  
        if (entry.uncompressedSize            === 0xffffffff ||
            entry.compressedSize              === 0xffffffff ||
            entry.relativeOffsetOfLocalHeader === 0xffffffff) {
          // ZIP64 format
          // find the Zip64 Extended Information Extra Field
          var zip64EiefBuffer = null;
          for (var i = 0; i < entry.extraFields.length; i++) {
            var extraField = entry.extraFields[i];
            if (extraField.id === 0x0001) {
              zip64EiefBuffer = extraField.data;
              break;
            }
          }
          if (zip64EiefBuffer == null) {
            return emitErrorAndAutoClose(self, new Error("expected zip64 extended information extra field"));
          }
          var index = 0;
          // 0 - Original Size          8 bytes
          if (entry.uncompressedSize === 0xffffffff) {
            if (index + 8 > zip64EiefBuffer.length) {
              return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include uncompressed size"));
            }
            entry.uncompressedSize = readUInt64LE(zip64EiefBuffer, index);
            index += 8;
          }
          // 8 - Compressed Size        8 bytes
          if (entry.compressedSize === 0xffffffff) {
            if (index + 8 > zip64EiefBuffer.length) {
              return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include compressed size"));
            }
            entry.compressedSize = readUInt64LE(zip64EiefBuffer, index);
            index += 8;
          }
          // 16 - Relative Header Offset 8 bytes
          if (entry.relativeOffsetOfLocalHeader === 0xffffffff) {
            if (index + 8 > zip64EiefBuffer.length) {
              return emitErrorAndAutoClose(self, new Error("zip64 extended information extra field does not include relative header offset"));
            }
            entry.relativeOffsetOfLocalHeader = readUInt64LE(zip64EiefBuffer, index);
            index += 8;
          }
          // 24 - Disk Start Number      4 bytes
        }
  
        // check for Info-ZIP Unicode Path Extra Field (0x7075)
        // see https://github.com/thejoshwolfe/yauzl/issues/33
        if (self.decodeStrings) {
          for (var i = 0; i < entry.extraFields.length; i++) {
            var extraField = entry.extraFields[i];
            if (extraField.id === 0x7075) {
              if (extraField.data.length < 6) {
                // too short to be meaningful
                continue;
              }
              // Version       1 byte      version of this extra field, currently 1
              if (extraField.data.readUInt8(0) !== 1) {
                // > Changes may not be backward compatible so this extra
                // > field should not be used if the version is not recognized.
                continue;
              }
              // NameCRC32     4 bytes     File Name Field CRC32 Checksum
              var oldNameCrc32 = extraField.data.readUInt32LE(1);
              if (crc32.unsigned(buffer.slice(0, entry.fileNameLength)) !== oldNameCrc32) {
                // > If the CRC check fails, this UTF-8 Path Extra Field should be
                // > ignored and the File Name field in the header should be used instead.
                continue;
              }
              // UnicodeName   Variable    UTF-8 version of the entry File Name
              entry.fileName = decodeBuffer(extraField.data, 5, extraField.data.length, true);
              break;
            }
          }
        }
  
        // validate file size
        if (self.validateEntrySizes && entry.compressionMethod === 0) {
          var expectedCompressedSize = entry.uncompressedSize;
          if (entry.isEncrypted()) {
            // traditional encryption prefixes the file data with a header
            expectedCompressedSize += 12;
          }
          if (entry.compressedSize !== expectedCompressedSize) {
            var msg = "compressed/uncompressed size mismatch for stored file: " + entry.compressedSize + " != " + entry.uncompressedSize;
            return emitErrorAndAutoClose(self, new Error(msg));
          }
        }
  
        if (self.decodeStrings) {
          if (!self.strictFileNames) {
            // allow backslash
            entry.fileName = entry.fileName.replace(/\\/g, "/");
          }
          var errorMessage = validateFileName(entry.fileName, self.validateFileNameOptions);
          if (errorMessage != null) return emitErrorAndAutoClose(self, new Error(errorMessage));
        }
        self.emit("entry", entry);
  
        if (!self.lazyEntries) self._readEntry();
      });
    });
  };
  
  ZipFile.prototype.openReadStream = function(entry, options, callback) {
    var self = this;
    // parameter validation
    var relativeStart = 0;
    var relativeEnd = entry.compressedSize;
    if (callback == null) {
      callback = options;
      options = {};
    } else {
      // validate options that the caller has no excuse to get wrong
      if (options.decrypt != null) {
        if (!entry.isEncrypted()) {
          throw new Error("options.decrypt can only be specified for encrypted entries");
        }
        if (options.decrypt !== false) throw new Error("invalid options.decrypt value: " + options.decrypt);
        if (entry.isCompressed()) {
          if (options.decompress !== false) throw new Error("entry is encrypted and compressed, and options.decompress !== false");
        }
      }
      if (options.decompress != null) {
        if (!entry.isCompressed()) {
          throw new Error("options.decompress can only be specified for compressed entries");
        }
        if (!(options.decompress === false || options.decompress === true)) {
          throw new Error("invalid options.decompress value: " + options.decompress);
        }
      }
      if (options.start != null || options.end != null) {
        if (entry.isCompressed() && options.decompress !== false) {
          throw new Error("start/end range not allowed for compressed entry without options.decompress === false");
        }
        if (entry.isEncrypted() && options.decrypt !== false) {
          throw new Error("start/end range not allowed for encrypted entry without options.decrypt === false");
        }
      }
      if (options.start != null) {
        relativeStart = options.start;
        if (relativeStart < 0) throw new Error("options.start < 0");
        if (relativeStart > entry.compressedSize) throw new Error("options.start > entry.compressedSize");
      }
      if (options.end != null) {
        relativeEnd = options.end;
        if (relativeEnd < 0) throw new Error("options.end < 0");
        if (relativeEnd > entry.compressedSize) throw new Error("options.end > entry.compressedSize");
        if (relativeEnd < relativeStart) throw new Error("options.end < options.start");
      }
    }
    // any further errors can either be caused by the zipfile,
    // or were introduced in a minor version of yauzl,
    // so should be passed to the client rather than thrown.
    if (!self.isOpen) return callback(new Error("closed"));
    if (entry.isEncrypted()) {
      if (options.decrypt !== false) return callback(new Error("entry is encrypted, and options.decrypt !== false"));
    }
    // make sure we don't lose the fd before we open the actual read stream
    self.reader.ref();
    var buffer = newBuffer(30);
    readAndAssertNoEof(self.reader, buffer, 0, buffer.length, entry.relativeOffsetOfLocalHeader, function(err) {
      try {
        if (err) return callback(err);
        // 0 - Local file header signature = 0x04034b50
        var signature = buffer.readUInt32LE(0);
        if (signature !== 0x04034b50) {
          return callback(new Error("invalid local file header signature: 0x" + signature.toString(16)));
        }
        // all this should be redundant
        // 4 - Version needed to extract (minimum)
        // 6 - General purpose bit flag
        // 8 - Compression method
        // 10 - File last modification time
        // 12 - File last modification date
        // 14 - CRC-32
        // 18 - Compressed size
        // 22 - Uncompressed size
        // 26 - File name length (n)
        var fileNameLength = buffer.readUInt16LE(26);
        // 28 - Extra field length (m)
        var extraFieldLength = buffer.readUInt16LE(28);
        // 30 - File name
        // 30+n - Extra field
        var localFileHeaderEnd = entry.relativeOffsetOfLocalHeader + buffer.length + fileNameLength + extraFieldLength;
        var decompress;
        if (entry.compressionMethod === 0) {
          // 0 - The file is stored (no compression)
          decompress = false;
        } else if (entry.compressionMethod === 8) {
          // 8 - The file is Deflated
          decompress = options.decompress != null ? options.decompress : true;
        } else {
          return callback(new Error("unsupported compression method: " + entry.compressionMethod));
        }
        var fileDataStart = localFileHeaderEnd;
        var fileDataEnd = fileDataStart + entry.compressedSize;
        if (entry.compressedSize !== 0) {
          // bounds check now, because the read streams will probably not complain loud enough.
          // since we're dealing with an unsigned offset plus an unsigned size,
          // we only have 1 thing to check for.
          if (fileDataEnd > self.fileSize) {
            return callback(new Error("file data overflows file bounds: " +
                fileDataStart + " + " + entry.compressedSize + " > " + self.fileSize));
          }
        }
        var readStream = self.reader.createReadStream({
          start: fileDataStart + relativeStart,
          end: fileDataStart + relativeEnd,
        });
        var endpointStream = readStream;
        if (decompress) {
          var destroyed = false;
          var inflateFilter = zlib.createInflateRaw();
          readStream.on("error", function(err) {
            // setImmediate here because errors can be emitted during the first call to pipe()
            setImmediate(function() {
              if (!destroyed) inflateFilter.emit("error", err);
            });
          });
          readStream.pipe(inflateFilter);
  
          if (self.validateEntrySizes) {
            endpointStream = new AssertByteCountStream(entry.uncompressedSize);
            inflateFilter.on("error", function(err) {
              // forward zlib errors to the client-visible stream
              setImmediate(function() {
                if (!destroyed) endpointStream.emit("error", err);
              });
            });
            inflateFilter.pipe(endpointStream);
          } else {
            // the zlib filter is the client-visible stream
            endpointStream = inflateFilter;
          }
          // this is part of yauzl's API, so implement this function on the client-visible stream
          endpointStream.destroy = function() {
            destroyed = true;
            if (inflateFilter !== endpointStream) inflateFilter.unpipe(endpointStream);
            readStream.unpipe(inflateFilter);
            // TODO: the inflateFilter may cause a memory leak. see Issue #27.
            readStream.destroy();
          };
        }
        callback(null, endpointStream);
      } finally {
        self.reader.unref();
      }
    });
  };
  
  function Entry() {
  }
  Entry.prototype.getLastModDate = function() {
    return dosDateTimeToDate(this.lastModFileDate, this.lastModFileTime);
  };
  Entry.prototype.isEncrypted = function() {
    return (this.generalPurposeBitFlag & 0x1) !== 0;
  };
  Entry.prototype.isCompressed = function() {
    return this.compressionMethod === 8;
  };
  
  function dosDateTimeToDate(date, time) {
    var day = date & 0x1f; // 1-31
    var month = (date >> 5 & 0xf) - 1; // 1-12, 0-11
    var year = (date >> 9 & 0x7f) + 1980; // 0-128, 1980-2108
  
    var millisecond = 0;
    var second = (time & 0x1f) * 2; // 0-29, 0-58 (even numbers)
    var minute = time >> 5 & 0x3f; // 0-59
    var hour = time >> 11 & 0x1f; // 0-23
  
    return new Date(year, month, day, hour, minute, second, millisecond);
  }
  
  function validateFileName(fileName) {
    if (fileName.indexOf("\\") !== -1) {
      return "invalid characters in fileName: " + fileName;
    }
    if (/^[a-zA-Z]:/.test(fileName) || /^\//.test(fileName)) {
      return "absolute path: " + fileName;
    }
    if (fileName.split("/").indexOf("..") !== -1) {
      return "invalid relative path: " + fileName;
    }
    // all good
    return null;
  }
  
  function readAndAssertNoEof(reader, buffer, offset, length, position, callback) {
    if (length === 0) {
      // fs.read will throw an out-of-bounds error if you try to read 0 bytes from a 0 byte file
      return setImmediate(function() { callback(null, newBuffer(0)); });
    }
    reader.read(buffer, offset, length, position, function(err, bytesRead) {
      if (err) return callback(err);
      if (bytesRead < length) {
        return callback(new Error("unexpected EOF"));
      }
      callback();
    });
  }
  
  util.inherits(AssertByteCountStream, Transform);
  function AssertByteCountStream(byteCount) {
    Transform.call(this);
    this.actualByteCount = 0;
    this.expectedByteCount = byteCount;
  }
  AssertByteCountStream.prototype._transform = function(chunk, encoding, cb) {
    this.actualByteCount += chunk.length;
    if (this.actualByteCount > this.expectedByteCount) {
      var msg = "too many bytes in the stream. expected " + this.expectedByteCount + ". got at least " + this.actualByteCount;
      return cb(new Error(msg));
    }
    cb(null, chunk);
  };
  AssertByteCountStream.prototype._flush = function(cb) {
    if (this.actualByteCount < this.expectedByteCount) {
      var msg = "not enough bytes in the stream. expected " + this.expectedByteCount + ". got only " + this.actualByteCount;
      return cb(new Error(msg));
    }
    cb();
  };
  
  util.inherits(RandomAccessReader, EventEmitter);
  function RandomAccessReader() {
    EventEmitter.call(this);
    this.refCount = 0;
  }
  RandomAccessReader.prototype.ref = function() {
    this.refCount += 1;
  };
  RandomAccessReader.prototype.unref = function() {
    var self = this;
    self.refCount -= 1;
  
    if (self.refCount > 0) return;
    if (self.refCount < 0) throw new Error("invalid unref");
  
    self.close(onCloseDone);
  
    function onCloseDone(err) {
      if (err) return self.emit('error', err);
      self.emit('close');
    }
  };
  RandomAccessReader.prototype.createReadStream = function(options) {
    var start = options.start;
    var end = options.end;
    if (start === end) {
      var emptyStream = new PassThrough();
      setImmediate(function() {
        emptyStream.end();
      });
      return emptyStream;
    }
    var stream = this._readStreamForRange(start, end);
  
    var destroyed = false;
    var refUnrefFilter = new RefUnrefFilter(this);
    stream.on("error", function(err) {
      setImmediate(function() {
        if (!destroyed) refUnrefFilter.emit("error", err);
      });
    });
    refUnrefFilter.destroy = function() {
      stream.unpipe(refUnrefFilter);
      refUnrefFilter.unref();
      stream.destroy();
    };
  
    var byteCounter = new AssertByteCountStream(end - start);
    refUnrefFilter.on("error", function(err) {
      setImmediate(function() {
        if (!destroyed) byteCounter.emit("error", err);
      });
    });
    byteCounter.destroy = function() {
      destroyed = true;
      refUnrefFilter.unpipe(byteCounter);
      refUnrefFilter.destroy();
    };
  
    return stream.pipe(refUnrefFilter).pipe(byteCounter);
  };
  RandomAccessReader.prototype._readStreamForRange = function(start, end) {
    throw new Error("not implemented");
  };
  RandomAccessReader.prototype.read = function(buffer, offset, length, position, callback) {
    var readStream = this.createReadStream({start: position, end: position + length});
    var writeStream = new Writable();
    var written = 0;
    writeStream._write = function(chunk, encoding, cb) {
      chunk.copy(buffer, offset + written, 0, chunk.length);
      written += chunk.length;
      cb();
    };
    writeStream.on("finish", callback);
    readStream.on("error", function(error) {
      callback(error);
    });
    readStream.pipe(writeStream);
  };
  RandomAccessReader.prototype.close = function(callback) {
    setImmediate(callback);
  };
  
  util.inherits(RefUnrefFilter, PassThrough);
  function RefUnrefFilter(context) {
    PassThrough.call(this);
    this.context = context;
    this.context.ref();
    this.unreffedYet = false;
  }
  RefUnrefFilter.prototype._flush = function(cb) {
    this.unref();
    cb();
  };
  RefUnrefFilter.prototype.unref = function(cb) {
    if (this.unreffedYet) return;
    this.unreffedYet = true;
    this.context.unref();
  };
  
  var cp437 = '\u0000☺☻♥♦♣♠•◘○◙♂♀♪♫☼►◄↕‼¶§▬↨↑↓→←∟↔▲▼ !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~⌂ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜ¢£¥₧ƒáíóúñÑªº¿⌐¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αßΓπΣσµτΦΘΩδ∞φε∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■ ';
  function decodeBuffer(buffer, start, end, isUtf8) {
    if (isUtf8) {
      return buffer.toString("utf8", start, end);
    } else {
      var result = "";
      for (var i = start; i < end; i++) {
        result += cp437[buffer[i]];
      }
      return result;
    }
  }
  
  function readUInt64LE(buffer, offset) {
    // there is no native function for this, because we can't actually store 64-bit integers precisely.
    // after 53 bits, JavaScript's Number type (IEEE 754 double) can't store individual integers anymore.
    // but since 53 bits is a whole lot more than 32 bits, we do our best anyway.
    var lower32 = buffer.readUInt32LE(offset);
    var upper32 = buffer.readUInt32LE(offset + 4);
    // we can't use bitshifting here, because JavaScript bitshifting only works on 32-bit integers.
    return upper32 * 0x100000000 + lower32;
    // as long as we're bounds checking the result of this function against the total file size,
    // we'll catch any overflow errors, because we already made sure the total file size was within reason.
  }
  
  // Node 10 deprecated new Buffer().
  var newBuffer;
  if (typeof Buffer.allocUnsafe === "function") {
    newBuffer = function(len) {
      return Buffer.allocUnsafe(len);
    };
  } else {
    newBuffer = function(len) {
      return new Buffer(len);
    };
  }
  
  function defaultCallback(err) {
    if (err) throw err;
  }
  
  
  /***/ }),
  
  /***/ 9449:
  /***/ ((module) => {
  
  module.exports = eval("require")("memcpy");
  
  
  /***/ }),
  
  /***/ 4293:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("buffer");;
  
  /***/ }),
  
  /***/ 8614:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("events");;
  
  /***/ }),
  
  /***/ 5747:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("fs");;
  
  /***/ }),
  
  /***/ 2087:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("os");;
  
  /***/ }),
  
  /***/ 5622:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("path");;
  
  /***/ }),
  
  /***/ 2413:
  /***/ ((module) => {
  
  "use strict";
  module.exports = require("stream");;
  
  /***/ }),
  
  /***/ 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
  /******/ 		var cachedModule = __webpack_module_cache__[moduleId];
  /******/ 		if (cachedModule !== undefined) {
  /******/ 			return cachedModule.exports;
  /******/ 		}
  /******/ 		// Create a new module (and put it into the cache)
  /******/ 		var module = __webpack_module_cache__[moduleId] = {
  /******/ 			id: moduleId,
  /******/ 			loaded: false,
  /******/ 			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];
  /******/ 		}
  /******/ 	
  /******/ 		// Flag the module as loaded
  /******/ 		module.loaded = true;
  /******/ 	
  /******/ 		// Return the exports of the module
  /******/ 		return module.exports;
  /******/ 	}
  /******/ 	
  /************************************************************************/
  /******/ 	/* webpack/runtime/node module decorator */
  /******/ 	(() => {
  /******/ 		__nccwpck_require__.nmd = (module) => {
  /******/ 			module.paths = [];
  /******/ 			if (!module.children) module.children = [];
  /******/ 			return module;
  /******/ 		};
  /******/ 	})();
  /******/ 	
  /******/ 	/* webpack/runtime/compat */
  /******/ 	
  /******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";/************************************************************************/
  var __webpack_exports__ = {};
  // This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
  (() => {
  const core = __nccwpck_require__(8041);
  const AppInfoParser = __nccwpck_require__(4355);
  
  async function main() {
      try {
          // inputs from action
          const aarPath = core.getInput('aarPath');
  
          console.log(aarPath);
  
          const parser = new AppInfoParser(aarPath);
          parser.parse().then(result => {
  
              core.setOutput("versionCode", result.versionCode);
              core.setOutput("versionName", result.versionName);
              core.setOutput("package", result.package);
              console.log('app info ----> ', result);
  
          }).catch(err => {
              console.log('err ----> ', err)
          });
  
      } catch (error) {
          console.log('catch error ----> ', error);
          core.setFailed(error.message);
      }
  }
  
  
  main();
  
  })();
  
  module.exports = __webpack_exports__;
  /******/ })()
  ;