verdaccio/build/lib/local-storage.js

A lightweight private npm proxy registry

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _assert = _interopRequireDefault(require("assert"));

var _url = _interopRequireDefault(require("url"));

var _lodash = _interopRequireDefault(require("lodash"));

var _localStorage = _interopRequireDefault(require("@verdaccio/local-storage"));

var _streams = require("@verdaccio/streams");

var _pluginLoader = _interopRequireDefault(require("../lib/plugin-loader"));

var _utils = require("./utils");

var _storageUtils = require("./storage-utils");

var _constants = require("./constants");

var _cryptoUtils = require("./crypto-utils");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

/**
 * Implements Storage interface (same for storage.js, local-storage.js, up-storage.js).
 */
class LocalStorage {
  constructor(config, logger) {
    _defineProperty(this, "config", void 0);

    _defineProperty(this, "storagePlugin", void 0);

    _defineProperty(this, "logger", void 0);

    this.logger = logger.child({
      sub: 'fs'
    });
    this.config = config;
    this.storagePlugin = this._loadStorage(config, logger);
  }

  addPackage(name, pkg, callback) {
    const storage = this._getLocalStorage(name);

    if (_lodash.default.isNil(storage)) {
      return callback(_utils.ErrorCode.getNotFound('this package cannot be added'));
    }

    storage.createPackage(name, (0, _storageUtils.generatePackageTemplate)(name), err => {
      // FIXME: it will be fixed here https://github.com/verdaccio/verdaccio/pull/1360
      // @ts-ignore
      if (_lodash.default.isNull(err) === false && (err.code === _constants.STORAGE.FILE_EXIST_ERROR || err.code === _constants.HTTP_STATUS.CONFLICT)) {
        return callback(_utils.ErrorCode.getConflict());
      }

      const latest = (0, _utils.getLatestVersion)(pkg);

      if (_lodash.default.isNil(latest) === false && pkg.versions[latest]) {
        return callback(null, pkg.versions[latest]);
      }

      return callback();
    });
  }
  /**
   * Remove package.
   * @param {*} name
   * @param {*} callback
   * @return {Function}
   */


  removePackage(name, callback) {
    const storage = this._getLocalStorage(name);

    this.logger.debug({
      name
    }, `[storage] removing package @{name}`);

    if (_lodash.default.isNil(storage)) {
      return callback(_utils.ErrorCode.getNotFound());
    }

    storage.readPackage(name, (err, data) => {
      if (_lodash.default.isNil(err) === false) {
        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
          return callback(_utils.ErrorCode.getNotFound());
        }

        return callback(err);
      }

      data = (0, _storageUtils.normalizePackage)(data);
      this.storagePlugin.remove(name, removeFailed => {
        if (removeFailed) {
          // This will happen when database is locked
          this.logger.debug({
            name
          }, `[storage/removePackage] the database is locked, removed has failed for @{name}`);
          return callback(_utils.ErrorCode.getBadData(removeFailed.message));
        }

        storage.deletePackage(_constants.STORAGE.PACKAGE_FILE_NAME, err => {
          if (err) {
            return callback(err);
          }

          const attachments = Object.keys(data._attachments);

          this._deleteAttachments(storage, attachments, callback);
        });
      });
    });
  }
  /**
   * Synchronize remote package info with the local one
   * @param {*} name
   * @param {*} packageInfo
   * @param {*} callback
   */


  updateVersions(name, packageInfo, callback) {
    this._readCreatePackage(name, (err, packageLocalJson) => {
      if (err) {
        return callback(err);
      }

      let change = false; // updating readme

      packageLocalJson.readme = (0, _storageUtils.getLatestReadme)(packageInfo);

      if (packageInfo.readme !== packageLocalJson.readme) {
        change = true;
      }

      for (const versionId in packageInfo.versions) {
        if (_lodash.default.isNil(packageLocalJson.versions[versionId])) {
          let version = packageInfo.versions[versionId]; // we don't keep readme for package versions,
          // only one readme per package

          version = (0, _storageUtils.cleanUpReadme)(version);
          version.contributors = (0, _storageUtils.normalizeContributors)(version.contributors);
          change = true;
          packageLocalJson.versions[versionId] = version;

          if (version.dist && version.dist.tarball) {
            const urlObject = _url.default.parse(version.dist.tarball);

            const filename = urlObject.pathname.replace(/^.*\//, ''); // we do NOT overwrite any existing records

            if (_lodash.default.isNil(packageLocalJson._distfiles[filename])) {
              const hash = packageLocalJson._distfiles[filename] = {
                url: version.dist.tarball,
                sha: version.dist.shasum
              };
              /* eslint spaced-comment: 0 */
              // $FlowFixMe

              const upLink = version[Symbol.for('__verdaccio_uplink')];

              if (_lodash.default.isNil(upLink) === false) {
                this._updateUplinkToRemoteProtocol(hash, upLink);
              }
            }
          }
        }
      }

      for (const tag in packageInfo[_constants.DIST_TAGS]) {
        if (!packageLocalJson[_constants.DIST_TAGS][tag] || packageLocalJson[_constants.DIST_TAGS][tag] !== packageInfo[_constants.DIST_TAGS][tag]) {
          change = true;
          packageLocalJson[_constants.DIST_TAGS][tag] = packageInfo[_constants.DIST_TAGS][tag];
        }
      }

      for (const up in packageInfo._uplinks) {
        if (Object.prototype.hasOwnProperty.call(packageInfo._uplinks, up)) {
          const need_change = !(0, _utils.isObject)(packageLocalJson._uplinks[up]) || packageInfo._uplinks[up].etag !== packageLocalJson._uplinks[up].etag || packageInfo._uplinks[up].fetched !== packageLocalJson._uplinks[up].fetched;

          if (need_change) {
            change = true;
            packageLocalJson._uplinks[up] = packageInfo._uplinks[up];
          }
        }
      }

      if ('time' in packageInfo && !_lodash.default.isEqual(packageLocalJson.time, packageInfo.time)) {
        packageLocalJson.time = packageInfo.time;
        change = true;
      }

      if (change) {
        this.logger.debug({
          name
        }, 'updating package @{name} info');

        this._writePackage(name, packageLocalJson, function (err) {
          callback(err, packageLocalJson);
        });
      } else {
        callback(null, packageLocalJson);
      }
    });
  }
  /**
   * Add a new version to a previous local package.
   * @param {*} name
   * @param {*} version
   * @param {*} metadata
   * @param {*} tag
   * @param {*} callback
   */


  addVersion(name, version, metadata, tag, callback) {
    this._updatePackage(name, (data, cb) => {
      // keep only one readme per package
      data.readme = metadata.readme; // TODO: lodash remove

      metadata = (0, _storageUtils.cleanUpReadme)(metadata);
      metadata.contributors = (0, _storageUtils.normalizeContributors)(metadata.contributors);
      const hasVersion = data.versions[version] != null;

      if (hasVersion) {
        return cb(_utils.ErrorCode.getConflict());
      } // if uploaded tarball has a different shasum, it's very likely that we have some kind of error


      if ((0, _utils.isObject)(metadata.dist) && _lodash.default.isString(metadata.dist.tarball)) {
        const tarball = metadata.dist.tarball.replace(/.*\//, '');

        if ((0, _utils.isObject)(data._attachments[tarball])) {
          if (_lodash.default.isNil(data._attachments[tarball].shasum) === false && _lodash.default.isNil(metadata.dist.shasum) === false) {
            if (data._attachments[tarball].shasum != metadata.dist.shasum) {
              const errorMessage = `shasum error, ${data._attachments[tarball].shasum} != ${metadata.dist.shasum}`;
              return cb(_utils.ErrorCode.getBadRequest(errorMessage));
            }
          }

          const currentDate = new Date().toISOString(); // some old storage do not have this field #740

          if (_lodash.default.isNil(data.time)) {
            data.time = {};
          }

          data.time['modified'] = currentDate;

          if ('created' in data.time === false) {
            data.time.created = currentDate;
          }

          data.time[version] = currentDate;
          data._attachments[tarball].version = version;
        }
      }

      data.versions[version] = metadata;
      (0, _utils.tagVersion)(data, version, tag);
      this.storagePlugin.add(name, addFailed => {
        if (addFailed) {
          return cb(_utils.ErrorCode.getBadData(addFailed.message));
        }

        cb();
      });
    }, callback);
  }
  /**
   * Merge a new list of tags for a local packages with the existing one.
   * @param {*} pkgName
   * @param {*} tags
   * @param {*} callback
   */


  mergeTags(pkgName, tags, callback) {
    this._updatePackage(pkgName, (data, cb) => {
      /* eslint guard-for-in: 0 */
      for (const tag in tags) {
        // this handle dist-tag rm command
        if (_lodash.default.isNull(tags[tag])) {
          delete data[_constants.DIST_TAGS][tag];
          continue;
        }

        if (_lodash.default.isNil(data.versions[tags[tag]])) {
          return cb(this._getVersionNotFound());
        }

        const version = tags[tag];
        (0, _utils.tagVersion)(data, version, tag);
      }

      cb(null);
    }, callback);
  }
  /**
   * Return version not found
   * @return {String}
   * @private
   */


  _getVersionNotFound() {
    return _utils.ErrorCode.getNotFound(_constants.API_ERROR.VERSION_NOT_EXIST);
  }
  /**
   * Return file no available
   * @return {String}
   * @private
   */


  _getFileNotAvailable() {
    return _utils.ErrorCode.getNotFound('no such file available');
  }
  /**
   * Update the package metadata, tags and attachments (tarballs).
   * Note: Currently supports unpublishing and deprecation.
   * @param {*} name
   * @param {*} incomingPkg
   * @param {*} revision
   * @param {*} callback
   * @return {Function}
   */


  changePackage(name, incomingPkg, revision, callback) {
    if (!(0, _utils.isObject)(incomingPkg.versions) || !(0, _utils.isObject)(incomingPkg[_constants.DIST_TAGS])) {
      this.logger.debug({
        name
      }, `changePackage bad data for @{name}`);
      return callback(_utils.ErrorCode.getBadData());
    }

    this.logger.debug({
      name
    }, `changePackage udapting package for @{name}`);

    this._updatePackage(name, (localData, cb) => {
      for (const version in localData.versions) {
        const incomingVersion = incomingPkg.versions[version];

        if (_lodash.default.isNil(incomingVersion)) {
          this.logger.info({
            name: name,
            version: version
          }, 'unpublishing @{name}@@{version}'); // FIXME: I prefer return a new object rather mutate the metadata

          delete localData.versions[version];
          delete localData.time[version];

          for (const file in localData._attachments) {
            if (localData._attachments[file].version === version) {
              delete localData._attachments[file].version;
            }
          }
        } else if (Object.prototype.hasOwnProperty.call(incomingVersion, 'deprecated')) {
          const incomingDeprecated = incomingVersion.deprecated;

          if (incomingDeprecated != localData.versions[version].deprecated) {
            if (!incomingDeprecated) {
              this.logger.info({
                name: name,
                version: version
              }, 'undeprecating @{name}@@{version}');
              delete localData.versions[version].deprecated;
            } else {
              this.logger.info({
                name: name,
                version: version
              }, 'deprecating @{name}@@{version}');
              localData.versions[version].deprecated = incomingDeprecated;
            }

            localData.time.modified = new Date().toISOString();
          }
        }
      }

      localData[_constants.USERS] = incomingPkg[_constants.USERS];
      localData[_constants.DIST_TAGS] = incomingPkg[_constants.DIST_TAGS];
      cb(null);
    }, function (err) {
      if (err) {
        return callback(err);
      }

      callback();
    });
  }
  /**
   * Remove a tarball.
   * @param {*} name
   * @param {*} filename
   * @param {*} revision
   * @param {*} callback
   */


  removeTarball(name, filename, revision, callback) {
    (0, _assert.default)((0, _utils.validateName)(filename));

    this._updatePackage(name, (data, cb) => {
      if (data._attachments[filename]) {
        delete data._attachments[filename];
        cb(null);
      } else {
        cb(this._getFileNotAvailable());
      }
    }, err => {
      if (err) {
        return callback(err);
      }

      const storage = this._getLocalStorage(name);

      if (storage) {
        storage.deletePackage(filename, callback);
      }
    });
  }
  /**
   * Add a tarball.
   * @param {String} name
   * @param {String} filename
   * @return {Stream}
   */


  addTarball(name, filename) {
    (0, _assert.default)((0, _utils.validateName)(filename));
    let length = 0;
    const shaOneHash = (0, _cryptoUtils.createTarballHash)();
    const uploadStream = new _streams.UploadTarball({});
    const _transform = uploadStream._transform;

    const storage = this._getLocalStorage(name);

    uploadStream.abort = function () {};

    uploadStream.done = function () {};

    uploadStream._transform = function (data, ...args) {
      shaOneHash.update(data); // measure the length for validation reasons

      length += data.length;
      const appliedData = [data, ...args]; // FIXME: not sure about this approach, tsc complains
      // @ts-ignore

      _transform.apply(uploadStream, appliedData);
    };

    if (name === '__proto__') {
      process.nextTick(() => {
        uploadStream.emit('error', _utils.ErrorCode.getForbidden());
      });
      return uploadStream;
    }

    if (!storage) {
      process.nextTick(() => {
        uploadStream.emit('error', "can't upload this package");
      });
      return uploadStream;
    }

    const writeStream = storage.writeTarball(filename);
    writeStream.on('error', err => {
      // @ts-ignore
      if (err.code === _constants.STORAGE.FILE_EXIST_ERROR || err.code === _constants.HTTP_STATUS.CONFLICT) {
        uploadStream.emit('error', _utils.ErrorCode.getConflict());
        uploadStream.abort(); // @ts-ignore
      } else if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
        // check if package exists to throw an appropriate message
        this.getPackageMetadata(name, function (_err, _res) {
          if (_err) {
            uploadStream.emit('error', _err);
          } else {
            uploadStream.emit('error', err);
          }
        });
      } else {
        uploadStream.emit('error', err);
      }
    });
    writeStream.on('open', function () {
      // re-emitting open because it's handled in storage.js
      uploadStream.emit('open');
    });
    writeStream.on('success', () => {
      this._updatePackage(name, function updater(data, cb) {
        data._attachments[filename] = {
          shasum: shaOneHash.digest('hex')
        };
        cb(null);
      }, function (err) {
        if (err) {
          uploadStream.emit('error', err);
        } else {
          uploadStream.emit('success');
        }
      });
    });

    uploadStream.abort = function () {
      writeStream.abort();
    };

    uploadStream.done = function () {
      if (!length) {
        uploadStream.emit('error', _utils.ErrorCode.getBadData('refusing to accept zero-length file'));
        writeStream.abort();
      } else {
        writeStream.done();
      }
    };

    uploadStream.pipe(writeStream);
    return uploadStream;
  }
  /**
   * Get a tarball.
   * @param {*} name
   * @param {*} filename
   * @return {ReadTarball}
   */


  getTarball(name, filename) {
    (0, _assert.default)((0, _utils.validateName)(filename));

    const storage = this._getLocalStorage(name);

    if (_lodash.default.isNil(storage)) {
      return this._createFailureStreamResponse();
    }

    return this._streamSuccessReadTarBall(storage, filename);
  }
  /**
   * Return a stream that emits a read failure.
   * @private
   * @return {ReadTarball}
   */


  _createFailureStreamResponse() {
    const stream = new _streams.ReadTarball({});
    process.nextTick(() => {
      stream.emit('error', this._getFileNotAvailable());
    });
    return stream;
  }
  /**
   * Return a stream that emits the tarball data
   * @param {Object} storage
   * @param {String} filename
   * @private
   * @return {ReadTarball}
   */


  _streamSuccessReadTarBall(storage, filename) {
    const stream = new _streams.ReadTarball({});
    const readTarballStream = storage.readTarball(filename);
    const e404 = _utils.ErrorCode.getNotFound;

    stream.abort = function () {
      if (_lodash.default.isNil(readTarballStream) === false) {
        readTarballStream.abort();
      }
    };

    readTarballStream.on('error', function (err) {
      // @ts-ignore
      if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
        stream.emit('error', e404('no such file available'));
      } else {
        stream.emit('error', err);
      }
    });
    readTarballStream.on('content-length', function (content) {
      stream.emit('content-length', content);
    });
    readTarballStream.on('open', function () {
      // re-emitting open because it's handled in storage.js
      stream.emit('open');
      readTarballStream.pipe(stream);
    });
    return stream;
  }
  /**
   * Retrieve a package by name.
   * @param {*} name
   * @param {*} callback
   * @return {Function}
   */


  getPackageMetadata(name, callback = () => {}) {
    const storage = this._getLocalStorage(name);

    if (_lodash.default.isNil(storage)) {
      return callback(_utils.ErrorCode.getNotFound());
    }

    this._readPackage(name, storage, callback);
  }
  /**
   * Search a local package.
   * @param {*} startKey
   * @param {*} options
   * @return {Function}
   */


  search(startKey, options) {
    const stream = new _streams.ReadTarball({
      objectMode: true
    });

    this._searchEachPackage((item, cb) => {
      // @ts-ignore
      if (item.time > parseInt(startKey, 10)) {
        this.getPackageMetadata(item.name, (err, data) => {
          if (err) {
            return cb(err);
          } // @ts-ignore


          const time = new Date(item.time).toISOString();
          const result = (0, _storageUtils.prepareSearchPackage)(data, time);

          if (_lodash.default.isNil(result) === false) {
            stream.push(result);
          }

          cb(null);
        });
      } else {
        cb(null);
      }
    }, function onEnd(err) {
      if (err) {
        stream.emit('error', err);
        return;
      }

      stream.end();
    });

    return stream;
  }
  /**
   * Retrieve a wrapper that provide access to the package location.
   * @param {Object} pkgName package name.
   * @return {Object}
   */


  _getLocalStorage(pkgName) {
    return this.storagePlugin.getPackageStorage(pkgName);
  }
  /**
   * Read a json file from storage.
   * @param {Object} storage
   * @param {Function} callback
   */


  _readPackage(name, storage, callback) {
    storage.readPackage(name, (err, result) => {
      if (err) {
        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
          return callback(_utils.ErrorCode.getNotFound());
        }

        return callback(this._internalError(err, _constants.STORAGE.PACKAGE_FILE_NAME, 'error reading'));
      }

      callback(err, (0, _storageUtils.normalizePackage)(result));
    });
  }
  /**
   * Walks through each package and calls `on_package` on them.
   * @param {*} onPackage
   * @param {*} onEnd
   */


  _searchEachPackage(onPackage, onEnd) {
    // save wait whether plugin still do not support search functionality
    if (_lodash.default.isNil(this.storagePlugin.search)) {
      this.logger.warn('plugin search not implemented yet');
      onEnd();
    } else {
      this.storagePlugin.search(onPackage, onEnd, _utils.validateName);
    }
  }
  /**
   * Retrieve either a previous created local package or a boilerplate.
   * @param {*} pkgName
   * @param {*} callback
   * @return {Function}
   */


  _readCreatePackage(pkgName, callback) {
    const storage = this._getLocalStorage(pkgName);

    if (_lodash.default.isNil(storage)) {
      this._createNewPackage(pkgName, callback);

      return;
    }

    storage.readPackage(pkgName, (err, data) => {
      // TODO: race condition
      if (_lodash.default.isNil(err) === false) {
        if (err.code === _constants.STORAGE.NO_SUCH_FILE_ERROR || err.code === _constants.HTTP_STATUS.NOT_FOUND) {
          data = (0, _storageUtils.generatePackageTemplate)(pkgName);
        } else {
          return callback(this._internalError(err, _constants.STORAGE.PACKAGE_FILE_NAME, 'error reading'));
        }
      }

      callback(null, (0, _storageUtils.normalizePackage)(data));
    });
  }

  _createNewPackage(name, callback) {
    return callback(null, (0, _storageUtils.normalizePackage)((0, _storageUtils.generatePackageTemplate)(name)));
  }
  /**
   * Handle internal error
   * @param {*} err
   * @param {*} file
   * @param {*} message
   * @return {Object} Error instance
   */


  _internalError(err, file, message) {
    this.logger.error({
      err: err,
      file: file
    }, `${message}  @{file}: @{!err.message}`);
    return _utils.ErrorCode.getInternalError();
  }
  /**
   * @param {*} name package name
   * @param {*} updateHandler function(package, cb) - update function
   * @param {*} callback callback that gets invoked after it's all updated
   * @return {Function}
   */


  _updatePackage(name, updateHandler, callback) {
    const storage = this._getLocalStorage(name);

    if (!storage) {
      return callback(_utils.ErrorCode.getNotFound());
    }

    storage.updatePackage(name, updateHandler, this._writePackage.bind(this), _storageUtils.normalizePackage, callback);
  }
  /**
   * Update the revision (_rev) string for a package.
   * @param {*} name
   * @param {*} json
   * @param {*} callback
   * @return {Function}
   */


  _writePackage(name, json, callback) {
    const storage = this._getLocalStorage(name);

    if (_lodash.default.isNil(storage)) {
      return callback();
    }

    storage.savePackage(name, this._setDefaultRevision(json), callback);
  }

  _setDefaultRevision(json) {
    // calculate revision from couch db
    if (_lodash.default.isString(json._rev) === false) {
      json._rev = _constants.STORAGE.DEFAULT_REVISION;
    } // this is intended in debug mode we do not want modify the store revision


    if (_lodash.default.isNil(this.config._debug)) {
      json._rev = (0, _storageUtils.generateRevision)(json._rev);
    }

    return json;
  }

  _deleteAttachments(storage, attachments, callback) {
    this.logger.debug({
      l: attachments.length
    }, `[storage/_deleteAttachments] delete attachments total: @{l}`);

    const unlinkNext = function (cb) {
      if (_lodash.default.isEmpty(attachments)) {
        return cb();
      }

      const attachment = attachments.shift();
      storage.deletePackage(attachment, function () {
        unlinkNext(cb);
      });
    };

    unlinkNext(function () {
      // try to unlink the directory, but ignore errors because it can fail
      storage.removePackage(function (err) {
        callback(err);
      });
    });
  }
  /**
   * Ensure the dist file remains as the same protocol
   * @param {Object} hash metadata
   * @param {String} upLinkKey registry key
   * @private
   */


  _updateUplinkToRemoteProtocol(hash, upLinkKey) {
    // if we got this information from a known registry,
    // use the same protocol for the tarball
    //
    // see https://github.com/rlidwka/sinopia/issues/166
    const tarballUrl = _url.default.parse(hash.url);

    const uplinkUrl = _url.default.parse(this.config.uplinks[upLinkKey].url);

    if (uplinkUrl.host === tarballUrl.host) {
      tarballUrl.protocol = uplinkUrl.protocol;
      hash.registry = upLinkKey;
      hash.url = _url.default.format(tarballUrl);
    }
  }

  async getSecret(config) {
    const secretKey = await this.storagePlugin.getSecret();
    return this.storagePlugin.setSecret(config.checkSecretKey(secretKey));
  }

  _loadStorage(config, logger) {
    const Storage = this._loadStorePlugin();

    if (_lodash.default.isNil(Storage)) {
      (0, _assert.default)(this.config.storage, 'CONFIG: storage path not defined');
      return new _localStorage.default(this.config, logger);
    }

    return Storage;
  }

  _loadStorePlugin() {
    const plugin_params = {
      config: this.config,
      logger: this.logger
    }; // eslint-disable-next-line max-len

    const plugins = (0, _pluginLoader.default)(this.config, this.config.store, plugin_params, plugin => {
      return plugin.getPackageStorage;
    });
    return _lodash.default.head(plugins);
  }

  saveToken(token) {
    if (_lodash.default.isFunction(this.storagePlugin.saveToken) === false) {
      return Promise.reject(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
    }

    return this.storagePlugin.saveToken(token);
  }

  deleteToken(user, tokenKey) {
    if (_lodash.default.isFunction(this.storagePlugin.deleteToken) === false) {
      return Promise.reject(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
    }

    return this.storagePlugin.deleteToken(user, tokenKey);
  }

  readTokens(filter) {
    if (_lodash.default.isFunction(this.storagePlugin.readTokens) === false) {
      return Promise.reject(_utils.ErrorCode.getCode(_constants.HTTP_STATUS.SERVICE_UNAVAILABLE, _constants.SUPPORT_ERRORS.PLUGIN_MISSING_INTERFACE));
    }

    return this.storagePlugin.readTokens(filter);
  }

}

var _default = LocalStorage;
exports.default = _default;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/lib/local-storage.ts"],"names":["LocalStorage","constructor","config","logger","child","sub","storagePlugin","_loadStorage","addPackage","name","pkg","callback","storage","_getLocalStorage","_","isNil","ErrorCode","getNotFound","createPackage","err","isNull","code","STORAGE","FILE_EXIST_ERROR","HTTP_STATUS","CONFLICT","getConflict","latest","versions","removePackage","debug","readPackage","data","NO_SUCH_FILE_ERROR","NOT_FOUND","remove","removeFailed","getBadData","message","deletePackage","PACKAGE_FILE_NAME","attachments","Object","keys","_attachments","_deleteAttachments","updateVersions","packageInfo","_readCreatePackage","packageLocalJson","change","readme","versionId","version","contributors","dist","tarball","urlObject","UrlNode","parse","filename","pathname","replace","_distfiles","hash","url","sha","shasum","upLink","Symbol","for","_updateUplinkToRemoteProtocol","tag","DIST_TAGS","up","_uplinks","prototype","hasOwnProperty","call","need_change","etag","fetched","isEqual","time","_writePackage","addVersion","metadata","_updatePackage","cb","hasVersion","isString","errorMessage","getBadRequest","currentDate","Date","toISOString","created","add","addFailed","mergeTags","pkgName","tags","_getVersionNotFound","API_ERROR","VERSION_NOT_EXIST","_getFileNotAvailable","changePackage","incomingPkg","revision","localData","incomingVersion","info","file","incomingDeprecated","deprecated","modified","USERS","removeTarball","addTarball","length","shaOneHash","uploadStream","UploadTarball","_transform","abort","done","args","update","appliedData","apply","process","nextTick","emit","getForbidden","writeStream","writeTarball","on","getPackageMetadata","_err","_res","updater","digest","pipe","getTarball","_createFailureStreamResponse","_streamSuccessReadTarBall","stream","ReadTarball","readTarballStream","readTarball","e404","content","_readPackage","search","startKey","options","objectMode","_searchEachPackage","item","parseInt","result","push","onEnd","end","getPackageStorage","_internalError","onPackage","warn","validateName","_createNewPackage","error","getInternalError","updateHandler","updatePackage","bind","normalizePackage","json","savePackage","_setDefaultRevision","_rev","DEFAULT_REVISION","_debug","l","unlinkNext","isEmpty","attachment","shift","upLinkKey","tarballUrl","uplinkUrl","uplinks","host","protocol","registry","format","getSecret","secretKey","setSecret","checkSecretKey","Storage","_loadStorePlugin","LocalDatabase","plugin_params","plugins","store","plugin","head","saveToken","token","isFunction","Promise","reject","getCode","SERVICE_UNAVAILABLE","SUPPORT_ERRORS","PLUGIN_MISSING_INTERFACE","deleteToken","user","tokenKey","readTokens","filter"],"mappings":";;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AAsBA;;AAEA;;AACA;;AAQA;;AACA;;;;;;AAGA;AACA;AACA;AACA,MAAMA,YAAN,CAAuC;AAK9BC,EAAAA,WAAW,CAACC,MAAD,EAAiBC,MAAjB,EAAiC;AAAA;;AAAA;;AAAA;;AACjD,SAAKA,MAAL,GAAcA,MAAM,CAACC,KAAP,CAAa;AAAEC,MAAAA,GAAG,EAAE;AAAP,KAAb,CAAd;AACA,SAAKH,MAAL,GAAcA,MAAd;AACA,SAAKI,aAAL,GAAqB,KAAKC,YAAL,CAAkBL,MAAlB,EAA0BC,MAA1B,CAArB;AACD;;AAEMK,EAAAA,UAAU,CAACC,IAAD,EAAeC,GAAf,EAA6BC,QAA7B,EAAuD;AACtE,UAAMC,OAAY,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,CAArB;;AAEA,QAAIK,gBAAEC,KAAF,CAAQH,OAAR,CAAJ,EAAsB;AACpB,aAAOD,QAAQ,CAACK,iBAAUC,WAAV,CAAsB,8BAAtB,CAAD,CAAf;AACD;;AAEDL,IAAAA,OAAO,CAACM,aAAR,CAAsBT,IAAtB,EAA4B,2CAAwBA,IAAxB,CAA5B,EAA4DU,GAAD,IAAS;AAClE;AACA;AACA,UACEL,gBAAEM,MAAF,CAASD,GAAT,MAAkB,KAAlB,KACCA,GAAG,CAACE,IAAJ,KAAaC,mBAAQC,gBAArB,IAAyCJ,GAAG,CAACE,IAAJ,KAAaG,uBAAYC,QADnE,CADF,EAGE;AACA,eAAOd,QAAQ,CAACK,iBAAUU,WAAV,EAAD,CAAf;AACD;;AAED,YAAMC,MAAM,GAAG,6BAAiBjB,GAAjB,CAAf;;AACA,UAAII,gBAAEC,KAAF,CAAQY,MAAR,MAAoB,KAApB,IAA6BjB,GAAG,CAACkB,QAAJ,CAAaD,MAAb,CAAjC,EAAuD;AACrD,eAAOhB,QAAQ,CAAC,IAAD,EAAOD,GAAG,CAACkB,QAAJ,CAAaD,MAAb,CAAP,CAAf;AACD;;AAED,aAAOhB,QAAQ,EAAf;AACD,KAhBD;AAiBD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACSkB,EAAAA,aAAa,CAACpB,IAAD,EAAeE,QAAf,EAAyC;AAC3D,UAAMC,OAAY,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,CAArB;;AACA,SAAKN,MAAL,CAAY2B,KAAZ,CAAkB;AAAErB,MAAAA;AAAF,KAAlB,EAA6B,oCAA7B;;AAEA,QAAIK,gBAAEC,KAAF,CAAQH,OAAR,CAAJ,EAAsB;AACpB,aAAOD,QAAQ,CAACK,iBAAUC,WAAV,EAAD,CAAf;AACD;;AAEDL,IAAAA,OAAO,CAACmB,WAAR,CAAoBtB,IAApB,EAA0B,CAACU,GAAD,EAAMa,IAAN,KAA8B;AACtD,UAAIlB,gBAAEC,KAAF,CAAQI,GAAR,MAAiB,KAArB,EAA4B;AAC1B,YAAIA,GAAG,CAACE,IAAJ,KAAaC,mBAAQW,kBAArB,IAA2Cd,GAAG,CAACE,IAAJ,KAAaG,uBAAYU,SAAxE,EAAmF;AACjF,iBAAOvB,QAAQ,CAACK,iBAAUC,WAAV,EAAD,CAAf;AACD;;AACD,eAAON,QAAQ,CAACQ,GAAD,CAAf;AACD;;AAEDa,MAAAA,IAAI,GAAG,oCAAiBA,IAAjB,CAAP;AAEA,WAAK1B,aAAL,CAAmB6B,MAAnB,CAA0B1B,IAA1B,EAAiC2B,YAAD,IAA+B;AAC7D,YAAIA,YAAJ,EAAkB;AAChB;AACA,eAAKjC,MAAL,CAAY2B,KAAZ,CACE;AAAErB,YAAAA;AAAF,WADF,EAEG,gFAFH;AAKA,iBAAOE,QAAQ,CAACK,iBAAUqB,UAAV,CAAqBD,YAAY,CAACE,OAAlC,CAAD,CAAf;AACD;;AAED1B,QAAAA,OAAO,CAAC2B,aAAR,CAAsBjB,mBAAQkB,iBAA9B,EAAkDrB,GAAD,IAAe;AAC9D,cAAIA,GAAJ,EAAS;AACP,mBAAOR,QAAQ,CAACQ,GAAD,CAAf;AACD;;AACD,gBAAMsB,WAAW,GAAGC,MAAM,CAACC,IAAP,CAAYX,IAAI,CAACY,YAAjB,CAApB;;AAEA,eAAKC,kBAAL,CAAwBjC,OAAxB,EAAiC6B,WAAjC,EAA8C9B,QAA9C;AACD,SAPD;AAQD,OAnBD;AAoBD,KA9BD;AA+BD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACSmC,EAAAA,cAAc,CAACrC,IAAD,EAAesC,WAAf,EAAqCpC,QAArC,EAA+D;AAClF,SAAKqC,kBAAL,CAAwBvC,IAAxB,EAA8B,CAACU,GAAD,EAAM8B,gBAAN,KAAiC;AAC7D,UAAI9B,GAAJ,EAAS;AACP,eAAOR,QAAQ,CAACQ,GAAD,CAAf;AACD;;AAED,UAAI+B,MAAM,GAAG,KAAb,CAL6D,CAM7D;;AACAD,MAAAA,gBAAgB,CAACE,MAAjB,GAA0B,mCAAgBJ,WAAhB,CAA1B;;AACA,UAAIA,WAAW,CAACI,MAAZ,KAAuBF,gBAAgB,CAACE,MAA5C,EAAoD;AAClDD,QAAAA,MAAM,GAAG,IAAT;AACD;;AACD,WAAK,MAAME,SAAX,IAAwBL,WAAW,CAACnB,QAApC,EAA8C;AAC5C,YAAId,gBAAEC,KAAF,CAAQkC,gBAAgB,CAACrB,QAAjB,CAA0BwB,SAA1B,CAAR,CAAJ,EAAmD;AACjD,cAAIC,OAAO,GAAGN,WAAW,CAACnB,QAAZ,CAAqBwB,SAArB,CAAd,CADiD,CAGjD;AACA;;AACAC,UAAAA,OAAO,GAAG,iCAAcA,OAAd,CAAV;AACAA,UAAAA,OAAO,CAACC,YAAR,GAAuB,yCAAsBD,OAAO,CAACC,YAA9B,CAAvB;AAEAJ,UAAAA,MAAM,GAAG,IAAT;AACAD,UAAAA,gBAAgB,CAACrB,QAAjB,CAA0BwB,SAA1B,IAAuCC,OAAvC;;AAEA,cAAIA,OAAO,CAACE,IAAR,IAAgBF,OAAO,CAACE,IAAR,CAAaC,OAAjC,EAA0C;AACxC,kBAAMC,SAAc,GAAGC,aAAQC,KAAR,CAAcN,OAAO,CAACE,IAAR,CAAaC,OAA3B,CAAvB;;AACA,kBAAMI,QAAQ,GAAGH,SAAS,CAACI,QAAV,CAAmBC,OAAnB,CAA2B,OAA3B,EAAoC,EAApC,CAAjB,CAFwC,CAIxC;;AACA,gBAAIhD,gBAAEC,KAAF,CAAQkC,gBAAgB,CAACc,UAAjB,CAA4BH,QAA5B,CAAR,CAAJ,EAAoD;AAClD,oBAAMI,IAAc,GAAIf,gBAAgB,CAACc,UAAjB,CAA4BH,QAA5B,IAAwC;AAC9DK,gBAAAA,GAAG,EAAEZ,OAAO,CAACE,IAAR,CAAaC,OAD4C;AAE9DU,gBAAAA,GAAG,EAAEb,OAAO,CAACE,IAAR,CAAaY;AAF4C,eAAhE;AAIA;AACA;;AACA,oBAAMC,MAAc,GAAGf,OAAO,CAACgB,MAAM,CAACC,GAAP,CAAW,oBAAX,CAAD,CAA9B;;AAEA,kBAAIxD,gBAAEC,KAAF,CAAQqD,MAAR,MAAoB,KAAxB,EAA+B;AAC7B,qBAAKG,6BAAL,CAAmCP,IAAnC,EAAyCI,MAAzC;AACD;AACF;AACF;AACF;AACF;;AAED,WAAK,MAAMI,GAAX,IAAkBzB,WAAW,CAAC0B,oBAAD,CAA7B,EAA0C;AACxC,YACE,CAACxB,gBAAgB,CAACwB,oBAAD,CAAhB,CAA4BD,GAA5B,CAAD,IACAvB,gBAAgB,CAACwB,oBAAD,CAAhB,CAA4BD,GAA5B,MAAqCzB,WAAW,CAAC0B,oBAAD,CAAX,CAAuBD,GAAvB,CAFvC,EAGE;AACAtB,UAAAA,MAAM,GAAG,IAAT;AACAD,UAAAA,gBAAgB,CAACwB,oBAAD,CAAhB,CAA4BD,GAA5B,IAAmCzB,WAAW,CAAC0B,oBAAD,CAAX,CAAuBD,GAAvB,CAAnC;AACD;AACF;;AAED,WAAK,MAAME,EAAX,IAAiB3B,WAAW,CAAC4B,QAA7B,EAAuC;AACrC,YAAIjC,MAAM,CAACkC,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqC/B,WAAW,CAAC4B,QAAjD,EAA2DD,EAA3D,CAAJ,EAAoE;AAClE,gBAAMK,WAAW,GACf,CAAC,qBAAS9B,gBAAgB,CAAC0B,QAAjB,CAA0BD,EAA1B,CAAT,CAAD,IACA3B,WAAW,CAAC4B,QAAZ,CAAqBD,EAArB,EAAyBM,IAAzB,KAAkC/B,gBAAgB,CAAC0B,QAAjB,CAA0BD,EAA1B,EAA8BM,IADhE,IAEAjC,WAAW,CAAC4B,QAAZ,CAAqBD,EAArB,EAAyBO,OAAzB,KAAqChC,gBAAgB,CAAC0B,QAAjB,CAA0BD,EAA1B,EAA8BO,OAHrE;;AAKA,cAAIF,WAAJ,EAAiB;AACf7B,YAAAA,MAAM,GAAG,IAAT;AACAD,YAAAA,gBAAgB,CAAC0B,QAAjB,CAA0BD,EAA1B,IAAgC3B,WAAW,CAAC4B,QAAZ,CAAqBD,EAArB,CAAhC;AACD;AACF;AACF;;AAED,UAAI,UAAU3B,WAAV,IAAyB,CAACjC,gBAAEoE,OAAF,CAAUjC,gBAAgB,CAACkC,IAA3B,EAAiCpC,WAAW,CAACoC,IAA7C,CAA9B,EAAkF;AAChFlC,QAAAA,gBAAgB,CAACkC,IAAjB,GAAwBpC,WAAW,CAACoC,IAApC;AACAjC,QAAAA,MAAM,GAAG,IAAT;AACD;;AAED,UAAIA,MAAJ,EAAY;AACV,aAAK/C,MAAL,CAAY2B,KAAZ,CAAkB;AAAErB,UAAAA;AAAF,SAAlB,EAA4B,+BAA5B;;AACA,aAAK2E,aAAL,CAAmB3E,IAAnB,EAAyBwC,gBAAzB,EAA2C,UAAU9B,GAAV,EAAqB;AAC9DR,UAAAA,QAAQ,CAACQ,GAAD,EAAM8B,gBAAN,CAAR;AACD,SAFD;AAGD,OALD,MAKO;AACLtC,QAAAA,QAAQ,CAAC,IAAD,EAAOsC,gBAAP,CAAR;AACD;AACF,KAlFD;AAmFD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;;;AACSoC,EAAAA,UAAU,CACf5E,IADe,EAEf4C,OAFe,EAGfiC,QAHe,EAIfd,GAJe,EAKf7D,QALe,EAMT;AACN,SAAK4E,cAAL,CACE9E,IADF,EAEE,CAACuB,IAAD,EAAOwD,EAAP,KAA8B;AAC5B;AACAxD,MAAAA,IAAI,CAACmB,MAAL,GAAcmC,QAAQ,CAACnC,MAAvB,CAF4B,CAI5B;;AACAmC,MAAAA,QAAQ,GAAG,iCAAcA,QAAd,CAAX;AACAA,MAAAA,QAAQ,CAAChC,YAAT,GAAwB,yCAAsBgC,QAAQ,CAAChC,YAA/B,CAAxB;AAEA,YAAMmC,UAAU,GAAGzD,IAAI,CAACJ,QAAL,CAAcyB,OAAd,KAA0B,IAA7C;;AACA,UAAIoC,UAAJ,EAAgB;AACd,eAAOD,EAAE,CAACxE,iBAAUU,WAAV,EAAD,CAAT;AACD,OAX2B,CAa5B;;;AACA,UAAI,qBAAS4D,QAAQ,CAAC/B,IAAlB,KAA2BzC,gBAAE4E,QAAF,CAAWJ,QAAQ,CAAC/B,IAAT,CAAcC,OAAzB,CAA/B,EAAkE;AAChE,cAAMA,OAAO,GAAG8B,QAAQ,CAAC/B,IAAT,CAAcC,OAAd,CAAsBM,OAAtB,CAA8B,MAA9B,EAAsC,EAAtC,CAAhB;;AAEA,YAAI,qBAAS9B,IAAI,CAACY,YAAL,CAAkBY,OAAlB,CAAT,CAAJ,EAA0C;AACxC,cACE1C,gBAAEC,KAAF,CAAQiB,IAAI,CAACY,YAAL,CAAkBY,OAAlB,EAA2BW,MAAnC,MAA+C,KAA/C,IACArD,gBAAEC,KAAF,CAAQuE,QAAQ,CAAC/B,IAAT,CAAcY,MAAtB,MAAkC,KAFpC,EAGE;AACA,gBAAInC,IAAI,CAACY,YAAL,CAAkBY,OAAlB,EAA2BW,MAA3B,IAAqCmB,QAAQ,CAAC/B,IAAT,CAAcY,MAAvD,EAA+D;AAC7D,oBAAMwB,YAAY,GAAI,iBAAgB3D,IAAI,CAACY,YAAL,CAAkBY,OAAlB,EAA2BW,MAAO,OAAMmB,QAAQ,CAAC/B,IAAT,CAAcY,MAAO,EAAnG;AACA,qBAAOqB,EAAE,CAACxE,iBAAU4E,aAAV,CAAwBD,YAAxB,CAAD,CAAT;AACD;AACF;;AAED,gBAAME,WAAW,GAAG,IAAIC,IAAJ,GAAWC,WAAX,EAApB,CAXwC,CAaxC;;AACA,cAAIjF,gBAAEC,KAAF,CAAQiB,IAAI,CAACmD,IAAb,CAAJ,EAAwB;AACtBnD,YAAAA,IAAI,CAACmD,IAAL,GAAY,EAAZ;AACD;;AAEDnD,UAAAA,IAAI,CAACmD,IAAL,CAAU,UAAV,IAAwBU,WAAxB;;AAEA,cAAI,aAAa7D,IAAI,CAACmD,IAAlB,KAA2B,KAA/B,EAAsC;AACpCnD,YAAAA,IAAI,CAACmD,IAAL,CAAUa,OAAV,GAAoBH,WAApB;AACD;;AAED7D,UAAAA,IAAI,CAACmD,IAAL,CAAU9B,OAAV,IAAqBwC,WAArB;AACA7D,UAAAA,IAAI,CAACY,YAAL,CAAkBY,OAAlB,EAA2BH,OAA3B,GAAqCA,OAArC;AACD;AACF;;AAEDrB,MAAAA,IAAI,CAACJ,QAAL,CAAcyB,OAAd,IAAyBiC,QAAzB;AACA,6BAAWtD,IAAX,EAAiBqB,OAAjB,EAA0BmB,GAA1B;AAEA,WAAKlE,aAAL,CAAmB2F,GAAnB,CAAuBxF,IAAvB,EAA8ByF,SAAD,IAAqB;AAChD,YAAIA,SAAJ,EAAe;AACb,iBAAOV,EAAE,CAACxE,iBAAUqB,UAAV,CAAqB6D,SAAS,CAAC5D,OAA/B,CAAD,CAAT;AACD;;AAEDkD,QAAAA,EAAE;AACH,OAND;AAOD,KA1DH,EA2DE7E,QA3DF;AA6DD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACSwF,EAAAA,SAAS,CAACC,OAAD,EAAkBC,IAAlB,EAAmC1F,QAAnC,EAAmE;AACjF,SAAK4E,cAAL,CACEa,OADF,EAEE,CAACpE,IAAD,EAAOwD,EAAP,KAAoB;AAClB;AACA,WAAK,MAAMhB,GAAX,IAAkB6B,IAAlB,EAAwB;AACtB;AACA,YAAIvF,gBAAEM,MAAF,CAASiF,IAAI,CAAC7B,GAAD,CAAb,CAAJ,EAAyB;AACvB,iBAAOxC,IAAI,CAACyC,oBAAD,CAAJ,CAAgBD,GAAhB,CAAP;AACA;AACD;;AAED,YAAI1D,gBAAEC,KAAF,CAAQiB,IAAI,CAACJ,QAAL,CAAcyE,IAAI,CAAC7B,GAAD,CAAlB,CAAR,CAAJ,EAAuC;AACrC,iBAAOgB,EAAE,CAAC,KAAKc,mBAAL,EAAD,CAAT;AACD;;AACD,cAAMjD,OAAe,GAAGgD,IAAI,CAAC7B,GAAD,CAA5B;AACA,+BAAWxC,IAAX,EAAiBqB,OAAjB,EAA0BmB,GAA1B;AACD;;AACDgB,MAAAA,EAAE,CAAC,IAAD,CAAF;AACD,KAlBH,EAmBE7E,QAnBF;AAqBD;AAED;AACF;AACA;AACA;AACA;;;AACU2F,EAAAA,mBAAmB,GAAmB;AAC5C,WAAOtF,iBAAUC,WAAV,CAAsBsF,qBAAUC,iBAAhC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;AACUC,EAAAA,oBAAoB,GAAmB;AAC7C,WAAOzF,iBAAUC,WAAV,CAAsB,wBAAtB,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AACSyF,EAAAA,aAAa,CAClBjG,IADkB,EAElBkG,WAFkB,EAGlBC,QAHkB,EAIlBjG,QAJkB,EAKZ;AACN,QAAI,CAAC,qBAASgG,WAAW,CAAC/E,QAArB,CAAD,IAAmC,CAAC,qBAAS+E,WAAW,CAAClC,oBAAD,CAApB,CAAxC,EAA0E;AACxE,WAAKtE,MAAL,CAAY2B,KAAZ,CAAkB;AAAErB,QAAAA;AAAF,OAAlB,EAA6B,oCAA7B;AACA,aAAOE,QAAQ,CAACK,iBAAUqB,UAAV,EAAD,CAAf;AACD;;AAED,SAAKlC,MAAL,CAAY2B,KAAZ,CAAkB;AAAErB,MAAAA;AAAF,KAAlB,EAA6B,4CAA7B;;AACA,SAAK8E,cAAL,CACE9E,IADF,EAEE,CAACoG,SAAD,EAAqBrB,EAArB,KAAkD;AAChD,WAAK,MAAMnC,OAAX,IAAsBwD,SAAS,CAACjF,QAAhC,EAA0C;AACxC,cAAMkF,eAAe,GAAGH,WAAW,CAAC/E,QAAZ,CAAqByB,OAArB,CAAxB;;AACA,YAAIvC,gBAAEC,KAAF,CAAQ+F,eAAR,CAAJ,EAA8B;AAC5B,eAAK3G,MAAL,CAAY4G,IAAZ,CAAiB;AAAEtG,YAAAA,IAAI,EAAEA,IAAR;AAAc4C,YAAAA,OAAO,EAAEA;AAAvB,WAAjB,EAAmD,iCAAnD,EAD4B,CAG5B;;AACA,iBAAOwD,SAAS,CAACjF,QAAV,CAAmByB,OAAnB,CAAP;AACA,iBAAOwD,SAAS,CAAC1B,IAAV,CAAgB9B,OAAhB,CAAP;;AAEA,eAAK,MAAM2D,IAAX,IAAmBH,SAAS,CAACjE,YAA7B,EAA2C;AACzC,gBAAIiE,SAAS,CAACjE,YAAV,CAAuBoE,IAAvB,EAA6B3D,OAA7B,KAAyCA,OAA7C,EAAsD;AACpD,qBAAOwD,SAAS,CAACjE,YAAV,CAAuBoE,IAAvB,EAA6B3D,OAApC;AACD;AACF;AACF,SAZD,MAYO,IAAIX,MAAM,CAACkC,SAAP,CAAiBC,cAAjB,CAAgCC,IAAhC,CAAqCgC,eAArC,EAAsD,YAAtD,CAAJ,EAAyE;AAC9E,gBAAMG,kBAAkB,GAAGH,eAAe,CAACI,UAA3C;;AACA,cAAID,kBAAkB,IAAIJ,SAAS,CAACjF,QAAV,CAAmByB,OAAnB,EAA4B6D,UAAtD,EAAkE;AAChE,gBAAI,CAACD,kBAAL,EAAyB;AACvB,mBAAK9G,MAAL,CAAY4G,IAAZ,CACE;AAAEtG,gBAAAA,IAAI,EAAEA,IAAR;AAAc4C,gBAAAA,OAAO,EAAEA;AAAvB,eADF,EAEE,kCAFF;AAIA,qBAAOwD,SAAS,CAACjF,QAAV,CAAmByB,OAAnB,EAA4B6D,UAAnC;AACD,aAND,MAMO;AACL,mBAAK/G,MAAL,CAAY4G,IAAZ,CACE;AAAEtG,gBAAAA,IAAI,EAAEA,IAAR;AAAc4C,gBAAAA,OAAO,EAAEA;AAAvB,eADF,EAEE,gCAFF;AAIAwD,cAAAA,SAAS,CAACjF,QAAV,CAAmByB,OAAnB,EAA4B6D,UAA5B,GAAyCD,kBAAzC;AACD;;AACDJ,YAAAA,SAAS,CAAC1B,IAAV,CAAgBgC,QAAhB,GAA2B,IAAIrB,IAAJ,GAAWC,WAAX,EAA3B;AACD;AACF;AACF;;AAEDc,MAAAA,SAAS,CAACO,gBAAD,CAAT,GAAmBT,WAAW,CAACS,gBAAD,CAA9B;AACAP,MAAAA,SAAS,CAACpC,oBAAD,CAAT,GAAuBkC,WAAW,CAAClC,oBAAD,CAAlC;AACAe,MAAAA,EAAE,CAAC,IAAD,CAAF;AACD,KAzCH,EA0CE,UAAUrE,GAAV,EAAqB;AACnB,UAAIA,GAAJ,EAAS;AACP,eAAOR,QAAQ,CAACQ,GAAD,CAAf;AACD;;AACDR,MAAAA,QAAQ;AACT,KA/CH;AAiDD;AACD;AACF;AACA;AACA;AACA;AACA;AACA;;;AACS0G,EAAAA,aAAa,CAClB5G,IADkB,EAElBmD,QAFkB,EAGlBgD,QAHkB,EAIlBjG,QAJkB,EAKZ;AACN,yBAAO,yBAAaiD,QAAb,CAAP;;AAEA,SAAK2B,cAAL,CACE9E,IADF,EAEE,CAACuB,IAAD,EAAOwD,EAAP,KAAoB;AAClB,UAAIxD,IAAI,CAACY,YAAL,CAAkBgB,QAAlB,CAAJ,EAAiC;AAC/B,eAAO5B,IAAI,CAACY,YAAL,CAAkBgB,QAAlB,CAAP;AACA4B,QAAAA,EAAE,CAAC,IAAD,CAAF;AACD,OAHD,MAGO;AACLA,QAAAA,EAAE,CAAC,KAAKiB,oBAAL,EAAD,CAAF;AACD;AACF,KATH,EAUGtF,GAAD,IAA+B;AAC7B,UAAIA,GAAJ,EAAS;AACP,eAAOR,QAAQ,CAACQ,GAAD,CAAf;AACD;;AACD,YAAMP,OAAO,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,CAAhB;;AAEA,UAAIG,OAAJ,EAAa;AACXA,QAAAA,OAAO,CAAC2B,aAAR,CAAsBqB,QAAtB,EAAgCjD,QAAhC;AACD;AACF,KAnBH;AAqBD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACS2G,EAAAA,UAAU,CAAC7G,IAAD,EAAemD,QAAf,EAAiD;AAChE,yBAAO,yBAAaA,QAAb,CAAP;AAEA,QAAI2D,MAAM,GAAG,CAAb;AACA,UAAMC,UAAU,GAAG,qCAAnB;AACA,UAAMC,YAA4B,GAAG,IAAIC,sBAAJ,CAAkB,EAAlB,CAArC;AACA,UAAMC,UAAU,GAAGF,YAAY,CAACE,UAAhC;;AACA,UAAM/G,OAAO,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,CAAhB;;AAEAgH,IAAAA,YAAY,CAACG,KAAb,GAAqB,YAAkB,CAAE,CAAzC;;AACAH,IAAAA,YAAY,CAACI,IAAb,GAAoB,YAAkB,CAAE,CAAxC;;AAEAJ,IAAAA,YAAY,CAACE,UAAb,GAA0B,UAAU3F,IAAV,EAAgB,GAAG8F,IAAnB,EAA+B;AACvDN,MAAAA,UAAU,CAACO,MAAX,CAAkB/F,IAAlB,EADuD,CAEvD;;AACAuF,MAAAA,MAAM,IAAIvF,IAAI,CAACuF,MAAf;AACA,YAAMS,WAAW,GAAG,CAAChG,IAAD,EAAO,GAAG8F,IAAV,CAApB,CAJuD,CAKvD;AACA;;AACAH,MAAAA,UAAU,CAACM,KAAX,CAAiBR,YAAjB,EAA+BO,WAA/B;AACD,KARD;;AAUA,QAAIvH,IAAI,KAAK,WAAb,EAA0B;AACxByH,MAAAA,OAAO,CAACC,QAAR,CAAiB,MAAY;AAC3BV,QAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BpH,iBAAUqH,YAAV,EAA3B;AACD,OAFD;AAGA,aAAOZ,YAAP;AACD;;AAED,QAAI,CAAC7G,OAAL,EAAc;AACZsH,MAAAA,OAAO,CAACC,QAAR,CAAiB,MAAY;AAC3BV,QAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2B,2BAA3B;AACD,OAFD;AAGA,aAAOX,YAAP;AACD;;AAED,UAAMa,WAA2B,GAAG1H,OAAO,CAAC2H,YAAR,CAAqB3E,QAArB,CAApC;AAEA0E,IAAAA,WAAW,CAACE,EAAZ,CAAe,OAAf,EAAyBrH,GAAD,IAAS;AAC/B;AACA,UAAIA,GAAG,CAACE,IAAJ,KAAaC,mBAAQC,gBAArB,IAAyCJ,GAAG,CAACE,IAAJ,KAAaG,uBAAYC,QAAtE,EAAgF;AAC9EgG,QAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BpH,iBAAUU,WAAV,EAA3B;AACA+F,QAAAA,YAAY,CAACG,KAAb,GAF8E,CAG9E;AACD,OAJD,MAIO,IAAIzG,GAAG,CAACE,IAAJ,KAAaC,mBAAQW,kBAArB,IAA2Cd,GAAG,CAACE,IAAJ,KAAaG,uBAAYU,SAAxE,EAAmF;AACxF;AACA,aAAKuG,kBAAL,CAAwBhI,IAAxB,EAA8B,UAAUiI,IAAV,EAAgCC,IAAhC,EAAqD;AACjF,cAAID,IAAJ,EAAU;AACRjB,YAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BM,IAA3B;AACD,WAFD,MAEO;AACLjB,YAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BjH,GAA3B;AACD;AACF,SAND;AAOD,OATM,MASA;AACLsG,QAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BjH,GAA3B;AACD;AACF,KAlBD;AAoBAmH,IAAAA,WAAW,CAACE,EAAZ,CAAe,MAAf,EAAuB,YAAkB;AACvC;AACAf,MAAAA,YAAY,CAACW,IAAb,CAAkB,MAAlB;AACD,KAHD;AAKAE,IAAAA,WAAW,CAACE,EAAZ,CAAe,SAAf,EAA0B,MAAY;AACpC,WAAKjD,cAAL,CACE9E,IADF,EAEE,SAASmI,OAAT,CAAiB5G,IAAjB,EAAuBwD,EAAvB,EAAiC;AAC/BxD,QAAAA,IAAI,CAACY,YAAL,CAAkBgB,QAAlB,IAA8B;AAC5BO,UAAAA,MAAM,EAAEqD,UAAU,CAACqB,MAAX,CAAkB,KAAlB;AADoB,SAA9B;AAGArD,QAAAA,EAAE,CAAC,IAAD,CAAF;AACD,OAPH,EAQE,UAAUrE,GAAV,EAAqB;AACnB,YAAIA,GAAJ,EAAS;AACPsG,UAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BjH,GAA3B;AACD,SAFD,MAEO;AACLsG,UAAAA,YAAY,CAACW,IAAb,CAAkB,SAAlB;AACD;AACF,OAdH;AAgBD,KAjBD;;AAmBAX,IAAAA,YAAY,CAACG,KAAb,GAAqB,YAAkB;AACrCU,MAAAA,WAAW,CAACV,KAAZ;AACD,KAFD;;AAIAH,IAAAA,YAAY,CAACI,IAAb,GAAoB,YAAkB;AACpC,UAAI,CAACN,MAAL,EAAa;AACXE,QAAAA,YAAY,CAACW,IAAb,CAAkB,OAAlB,EAA2BpH,iBAAUqB,UAAV,CAAqB,qCAArB,CAA3B;AACAiG,QAAAA,WAAW,CAACV,KAAZ;AACD,OAHD,MAGO;AACLU,QAAAA,WAAW,CAACT,IAAZ;AACD;AACF,KAPD;;AASAJ,IAAAA,YAAY,CAACqB,IAAb,CAAkBR,WAAlB;AAEA,WAAOb,YAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;;;AACSsB,EAAAA,UAAU,CAACtI,IAAD,EAAemD,QAAf,EAA+C;AAC9D,yBAAO,yBAAaA,QAAb,CAAP;;AAEA,UAAMhD,OAAwB,GAAG,KAAKC,gBAAL,CAAsBJ,IAAtB,CAAjC;;AAEA,QAAIK,gBAAEC,KAAF,CAAQH,OAAR,CAAJ,EAAsB;AACpB,aAAO,KAAKoI,4BAAL,EAAP;AACD;;AAED,WAAO,KAAKC,yBAAL,CAA+BrI,OAA/B,EAAwCgD,QAAxC,CAAP;AACD;AAED;AACF;AACA;AACA;AACA;;;AACUoF,EAAAA,4BAA4B,GAAiB;AACnD,UAAME,MAAoB,GAAG,IAAIC,oBAAJ,CAAgB,EAAhB,CAA7B;AAEAjB,IAAAA,OAAO,CAACC,QAAR,CAAiB,MAAY;AAC3Be,MAAAA,MAAM,CAACd,IAAP,CAAY,OAAZ,EAAqB,KAAK3B,oBAAL,EAArB;AACD,KAFD;AAGA,WAAOyC,MAAP;AACD;AAED;AACF;AACA;AACA;AACA;AACA;AACA;;;AACUD,EAAAA,yBAAyB,CAACrI,OAAD,EAAegD,QAAf,EAA+C;AAC9E,UAAMsF,MAAoB,GAAG,IAAIC,oBAAJ,CAAgB,EAAhB,CAA7B;AACA,UAAMC,iBAAiB,GAAGxI,OAAO,CAACyI,WAAR,CAAoBzF,QAApB,CAA1B;AACA,UAAM0F,IAAI,GAAGtI,iBAAUC,WAAvB;;AAEAiI,IAAAA,MAAM,CAACtB,KAAP,GAAe,YAAkB;AAC/B,UAAI9G,gBAAEC,KAAF,CAAQqI,iBAAR,MAA+B,KAAnC,EAA0C;AACxCA,QAAAA,iBAAiB,CAACxB,KAAlB;AACD;AACF,KA