text: "use strict";
  /**
   * var basex = require("base-x");
   *
   * This implementation is heavily based on base-x. The main reason to
   * deviate was to prevent the dependency of Buffer.
   *
   * Contributors:
   *
   * base-x encoding
   * Forked from https://github.com/cryptocoinjs/bs58
   * Originally written by Mike Hearn for BitcoinJ
   * Copyright (c) 2011 Google Inc
   * Ported to JavaScript by Stefan Thomas
   * Merged Buffer refactorings from base58-native by Stephen Pair
   * Copyright (c) 2013 BitPay Inc
   *
   * The MIT License (MIT)
   *
   * Copyright base-x contributors (c) 2016
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
  
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
   * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
   * IN THE SOFTWARE.
   *
   */
  Object.defineProperty(exports, "__esModule", { value: true });
  var bytes_1 = require("@ethersproject/bytes");
  var properties_1 = require("@ethersproject/properties");
  var BaseX = /** @class */ (function () {
      function BaseX(alphabet) {
          properties_1.defineReadOnly(this, "alphabet", alphabet);
          properties_1.defineReadOnly(this, "base", alphabet.length);
          properties_1.defineReadOnly(this, "_alphabetMap", {});
          properties_1.defineReadOnly(this, "_leader", alphabet.charAt(0));
          // pre-compute lookup table
          for (var i = 0; i < alphabet.length; i++) {
              this._alphabetMap[alphabet.charAt(i)] = i;
          }
      }
      BaseX.prototype.encode = function (value) {
          var source = bytes_1.arrayify(value);
          if (source.length === 0) {
              return "";
          }
          var digits = [0];
          for (var i = 0; i < source.length; ++i) {
              var carry = source[i];
              for (var j = 0; j < digits.length; ++j) {
                  carry += digits[j] << 8;
                  digits[j] = carry % this.base;
                  carry = (carry / this.base) | 0;
              }
              while (carry > 0) {
                  digits.push(carry % this.base);
                  carry = (carry / this.base) | 0;
              }
          }
          var string = "";
          // deal with leading zeros
          for (var k = 0; source[k] === 0 && k < source.length - 1; ++k) {
              string += this._leader;
          }
          // convert digits to a string
          for (var q = digits.length - 1; q >= 0; --q) {
              string += this.alphabet[digits[q]];
          }
          return string;
      };
      BaseX.prototype.decode = function (value) {
          if (typeof (value) !== "string") {
              throw new TypeError("Expected String");
          }
          var bytes = [];
          if (value.length === 0) {
              return new Uint8Array(bytes);
          }
          bytes.push(0);
          for (var i = 0; i < value.length; i++) {
              var byte = this._alphabetMap[value[i]];
              if (byte === undefined) {
                  throw new Error("Non-base" + this.base + " character");
              }
              var carry = byte;
              for (var j = 0; j < bytes.length; ++j) {
                  carry += bytes[j] * this.base;
                  bytes[j] = carry & 0xff;
                  carry >>= 8;
              }
              while (carry > 0) {
                  bytes.push(carry & 0xff);
                  carry >>= 8;
              }
          }
          // deal with leading zeros
          for (var k = 0; value[k] === this._leader && k < value.length - 1; ++k) {
              bytes.push(0);
          }
          return bytes_1.arrayify(new Uint8Array(bytes.reverse()));
      };
      return BaseX;
  }());
  exports.BaseX = BaseX;
  var Base32 = new BaseX("abcdefghijklmnopqrstuvwxyz234567");
  exports.Base32 = Base32;
  var Base58 = new BaseX("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
  exports.Base58 = Base58;
  //console.log(Base58.decode("Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj"))
  //console.log(Base58.encode(Base58.decode("Qmd2V777o5XvJbYMeMb8k2nU5f8d3ciUQ5YpYuWhzv8iDj")))
  