signify-ts 0.1.0 → 0.1.1

package/dist/signify-ts.cjs.development.js

@@ -2,12 +2,3387 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var sum = function sum(a, b) {
-  {
-    console.log('boop');
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var libsodium = _interopDefault(require('libsodium-wrappers-sumo'));
+var util = require('util');
+var Base64 = _interopDefault(require('urlsafe-base64'));
+var buffer = require('buffer');
+var blake3 = require('blake3');
+
+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, _toPropertyKey(descriptor.key), descriptor);
+  }
+}
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  Object.defineProperty(Constructor, "prototype", {
+    writable: false
+  });
+  return Constructor;
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+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 _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+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 _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 _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _toPrimitive(input, hint) {
+  if (typeof input !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (typeof res !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return typeof key === "symbol" ? key : String(key);
+}
+
+var EmptyMaterialError = /*#__PURE__*/function () {
+  function EmptyMaterialError(err) {
+    this._err = new Error(err);
+  }
+  _createClass(EmptyMaterialError, [{
+    key: "err",
+    get: function get() {
+      return this._err;
+    }
+  }]);
+  return EmptyMaterialError;
+}();
+
+var Serials;
+(function (Serials) {
+  Serials["JSON"] = "JSON";
+})(Serials || (Serials = {}));
+var Ident;
+(function (Ident) {
+  Ident["KERI"] = "KERI";
+})(Ident || (Ident = {}));
+var Version = function Version(major, minor) {
+  if (major === void 0) {
+    major = 1;
+  }
+  if (minor === void 0) {
+    minor = 0;
+  }
+  this.major = major;
+  this.minor = minor;
+};
+var Versionage = /*#__PURE__*/new Version();
+var Ilks = {
+  icp: 'icp',
+  rot: 'rot',
+  ixn: 'ixn',
+  dip: 'dip',
+  drt: 'drt',
+  rct: 'rct',
+  vrc: 'vrc'
+};
+var encoder = /*#__PURE__*/new util.TextEncoder();
+var decoder = /*#__PURE__*/new util.TextDecoder();
+// const version_pattern = 'KERI(?P<major>[0-9a-f])(?P<minor>[0-9a-f])
+// (?P<kind>[A-Z]{4})(?P<size>[0-9a-f]{6})'
+// const version_pattern1 = `KERI\(\?P<major>\[0\-9a\-f\]\)\(\?P<minor>\[0\-9a\-f\]\)\
+// (\?P<kind>\[A\-Z\]\{4\}\)\(\?P<size>\[0\-9a\-f\]\{6\}\)_`
+var VEREX = 'KERI([0-9a-f])([0-9a-f])([A-Z]{4})([0-9a-f]{6})_';
+// Regex pattern matching
+/**
+ * @description This function is use to deversify the version
+ * Here we will use regex to  to validate and extract serialization kind,size and version
+ * @param {string} versionString   version string
+ * @return {Object}  contaning kind of serialization like cbor,json,mgpk
+ *                    version = version of object ,size = raw size integer
+ */
+function deversify(versionString) {
+  var kind;
+  var size;
+  var version = Versionage;
+  // we need to identify how to match the buffers pattern ,like we do regex matching for strings
+  var re = new RegExp(VEREX);
+  var match = re.exec(versionString);
+  if (match) {
+    var _ref = [+match[1], +match[2], match[3], match[4]];
+    version.major = _ref[0];
+    version.minor = _ref[1];
+    kind = _ref[2];
+    size = _ref[3];
+    if (!Object.values(Serials).includes(kind)) {
+      throw new Error("Invalid serialization kind = " + kind);
+    }
+    var ta = kind;
+    kind = Serials[ta];
+    return [kind, version, size];
+  }
+  throw new Error("Invalid version string = " + versionString);
+}
+function versify(ident, version, kind, size) {
+  if (ident === void 0) {
+    ident = Ident.KERI;
+  }
+  if (kind === void 0) {
+    kind = Serials.JSON;
+  }
+  if (size === void 0) {
+    size = 0;
+  }
+  version = version == undefined ? Versionage : version;
+  return "" + ident + version.major.toString(16) + version.minor.toString() + kind + size.toString(16).padStart(6, '0') + "_";
+}
+var B64ChrByIdx = /*#__PURE__*/new Map([[0, 'A'], [1, 'B'], [2, 'C'], [3, 'D'], [4, 'E'], [5, 'F'], [6, 'G'], [7, 'H'], [8, 'I'], [9, 'J'], [10, 'K'], [11, 'L'], [12, 'M'], [13, 'N'], [14, 'O'], [15, 'P'], [16, 'Q'], [17, 'R'], [18, 'S'], [19, 'T'], [20, 'U'], [21, 'V'], [22, 'W'], [23, 'X'], [24, 'Y'], [25, 'Z'], [26, 'a'], [27, 'b'], [28, 'c'], [29, 'd'], [30, 'e'], [31, 'f'], [32, 'g'], [33, 'h'], [34, 'i'], [35, 'j'], [36, 'k'], [37, 'l'], [38, 'm'], [39, 'n'], [40, 'o'], [41, 'p'], [42, 'q'], [43, 'r'], [44, 's'], [45, 't'], [46, 'u'], [47, 'v'], [48, 'w'], [49, 'x'], [50, 'y'], [51, 'z'], [52, '0'], [53, '1'], [54, '2'], [55, '3'], [56, '4'], [57, '5'], [58, '6'], [59, '7'], [60, '8'], [61, '9'], [62, '-'], [63, '_']]);
+var B64IdxByChr = /*#__PURE__*/new Map( /*#__PURE__*/Array.from(B64ChrByIdx, function (entry) {
+  return [entry[1], entry[0]];
+}));
+function intToB64(i, l) {
+  if (l === void 0) {
+    l = 1;
+  }
+  var out = "";
+  while (l != 0) {
+    out = B64ChrByIdx.get(i % 64) + out;
+    i = Math.floor(i / 64);
+    if (i == 0) {
+      break;
+    }
+  }
+  var x = l - out.length;
+  for (var _i = 0; _i < x; _i++) {
+    out = "A" + out;
+  }
+  return out;
+}
+function b64ToInt(s) {
+  if (s.length == 0) {
+    throw new Error("Empty string, conversion undefined.");
+  }
+  var i = 0;
+  var rev = [].concat(s).reverse();
+  rev.forEach(function (c, e) {
+    i |= B64IdxByChr.get(c) << e * 6;
+  });
+  return i;
+}
+function b(s) {
+  return encoder.encode(s);
+}
+function d(u) {
+  return decoder.decode(u);
+}
+function readInt(array) {
+  var value = 0;
+  for (var i = 0; i < array.length; i++) {
+    value = value * 256 + array[i];
+  }
+  return value;
+}
+
+var Codex = /*#__PURE__*/function () {
+  function Codex() {}
+  var _proto = Codex.prototype;
+  _proto.has = function has(prop) {
+    var m = new Map(Array.from(Object.entries(this), function (v) {
+      return [v[1], v[0]];
+    }));
+    return m.has(prop);
+  };
+  return Codex;
+}();
+var MatterCodex = /*#__PURE__*/function (_Codex) {
+  _inheritsLoose(MatterCodex, _Codex);
+  function MatterCodex() {
+    var _this;
+    _this = _Codex.apply(this, arguments) || this;
+    _this.Ed25519_Seed = 'A'; // Ed25519 256 bit random seed for private key
+    _this.Ed25519N = 'B'; // Ed25519 verification key non-transferable, basic derivation.
+    _this.X25519 = 'C'; // X25519 public encryption key, converted from Ed25519 or Ed25519N.
+    _this.Ed25519 = 'D'; // Ed25519 verification key basic derivation
+    _this.Blake3_256 = 'E'; // Blake3 256 bit digest self-addressing derivation.
+    _this.X25519_Private = 'O'; // X25519 private decryption key converted from Ed25519
+    _this.X25519_Cipher_Seed = 'P'; // X25519 124 char b64 Cipher of 44 char qb64 Seed
+    _this.X25519_Cipher_Salt = '1AAH'; // X25519 100 char b64 Cipher of 24 char qb64 Salt
+    _this.Salt_128 = '0A'; // 128 bit random salt or 128 bit number (see Huge)
+    _this.Ed25519_Sig = '0B'; // Ed25519 signature.
+    return _this;
+  }
+  return MatterCodex;
+}(Codex);
+var MtrDex = /*#__PURE__*/new MatterCodex();
+var NonTransCodex = /*#__PURE__*/function (_Codex2) {
+  _inheritsLoose(NonTransCodex, _Codex2);
+  function NonTransCodex() {
+    var _this2;
+    _this2 = _Codex2.apply(this, arguments) || this;
+    _this2.Ed25519N = 'B'; // Ed25519 verification key non-transferable, basic derivation.
+    _this2.ECDSA_256k1N = '1AAA'; // ECDSA secp256k1 verification key non-transferable, basic derivation.
+    _this2.Ed448N = '1AAC'; // Ed448 non-transferable prefix public signing verification key. Basic derivation.
+    return _this2;
+  }
+  return NonTransCodex;
+}(Codex);
+var NonTransDex = /*#__PURE__*/new NonTransCodex();
+var DigiCodex = /*#__PURE__*/function (_Codex3) {
+  _inheritsLoose(DigiCodex, _Codex3);
+  function DigiCodex() {
+    var _this3;
+    _this3 = _Codex3.apply(this, arguments) || this;
+    _this3.Blake3_256 = 'E'; // Blake3 256 bit digest self-addressing derivation.
+    _this3.Blake2b_256 = 'F'; // Blake2b 256 bit digest self-addressing derivation.
+    _this3.Blake2s_256 = 'G'; // Blake2s 256 bit digest self-addressing derivation.
+    _this3.SHA3_256 = 'H'; // SHA3 256 bit digest self-addressing derivation.
+    _this3.SHA2_256 = 'I'; // SHA2 256 bit digest self-addressing derivation.
+    _this3.Blake3_512 = '0D'; // Blake3 512 bit digest self-addressing derivation.
+    _this3.Blake2b_512 = '0E'; // Blake2b 512 bit digest self-addressing derivation.
+    _this3.SHA3_512 = '0F'; // SHA3 512 bit digest self-addressing derivation.
+    _this3.SHA2_512 = '0G'; // SHA2 512 bit digest self-addressing derivation.
+    return _this3;
+  }
+  return DigiCodex;
+}(Codex);
+var DigiDex = /*#__PURE__*/new DigiCodex();
+var Sizage = function Sizage(hs, ss, fs, ls) {
+  this.hs = hs;
+  this.ss = ss;
+  this.fs = fs;
+  this.ls = ls;
+};
+var Matter = /*#__PURE__*/function () {
+  function Matter(_ref) {
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.Ed25519N : _ref$code,
+      qb64b = _ref.qb64b,
+      qb64 = _ref.qb64,
+      qb2 = _ref.qb2;
+    this._code = "";
+    this._size = -1;
+    this._raw = new Uint8Array(0);
+    var size = -1;
+    if (raw != undefined) {
+      if (code.length == 0) {
+        throw new Error("Improper initialization need either (raw and code) or qb64b or qb64 or qb2.");
+      }
+      // Add support for variable size codes here if needed, this code only works for stable size codes
+      var sizage = Matter.Sizes.get(code);
+      if (sizage.fs == -1) {
+        // invalid
+        throw new Error("Unsupported variable size code=" + code);
+      }
+      var rize = Matter._rawSize(code);
+      raw = raw.slice(0, rize); // copy only exact size from raw stream
+      if (raw.length != rize) {
+        // forbids shorter
+        throw new Error("Not enougth raw bytes for code=" + code + " expected " + rize + " got " + raw.length + ".");
+      }
+      this._code = code; // hard value part of code
+      this._size = size; // soft value part of code in int
+      this._raw = raw; // crypto ops require bytes not bytearray
+    } else if (qb64 !== undefined) {
+      this._exfil(qb64);
+    } else if (qb64b !== undefined) {
+      var _qb = d(qb64b);
+      this._exfil(_qb);
+    } else if (qb2 !== undefined) {
+      this._bexfil(qb2);
+    } else {
+      throw new EmptyMaterialError("EmptyMaterialError");
+    }
+  }
+  Matter._rawSize = function _rawSize(code) {
+    var sizage = this.Sizes.get(code); // get sizes
+    var cs = sizage.hs + sizage.ss; // both hard + soft code size
+    if (sizage.fs === -1) {
+      throw Error("Non-fixed raw size code " + code + ".");
+    }
+    return Math.floor((sizage.fs - cs) * 3 / 4) - sizage.ls;
+  };
+  Matter._leadSize = function _leadSize(code) {
+    var sizage = this.Sizes.get(code);
+    return sizage.ls;
+  };
+  var _proto2 = Matter.prototype;
+  _proto2._infil = function _infil() {
+    var code = this.code;
+    var raw = this.raw;
+    var ps = (3 - raw.length % 3) % 3; // pad size chars or lead size bytes
+    var sizage = Matter.Sizes.get(code);
+    if (sizage.fs === -1) {
+      // Variable size code, NOT SUPPORTED
+      throw new Error("Variable sized codes not supported... yet");
+    } else {
+      var both = code;
+      var cs = both.length;
+      if (cs % 4 != ps - sizage.ls) {
+        // adjusted pad given lead bytes
+        throw new Error("Invalid code=" + both + " for converted raw pad size=" + ps + ", " + raw.length + ".");
+      }
+      // prepad, convert, and replace upfront
+      // when fixed and ls != 0 then cs % 4 is zero and ps==ls
+      // otherwise  fixed and ls == 0 then cs % 4 == ps
+      var bytes = new Uint8Array(ps + raw.length);
+      for (var i = 0; i < ps; i++) {
+        bytes[i] = 0;
+      }
+      for (var _i = 0; _i < raw.length; _i++) {
+        var odx = _i + ps;
+        bytes[odx] = raw[_i];
+      }
+      return both + Base64.encode(buffer.Buffer.from(bytes)).slice(cs % 4);
+    }
+  };
+  _proto2._exfil = function _exfil(qb64) {
+    if (qb64.length == 0) {
+      throw new Error("Empty Material");
+    }
+    var first = qb64[0];
+    if (!Array.from(Matter.Hards.keys()).includes(first)) {
+      throw new Error("Unexpected code " + first);
+    }
+    var hs = Matter.Hards.get(first);
+    if (qb64.length < hs) {
+      throw new Error("Shortage Error");
+    }
+    var hard = qb64.slice(0, hs);
+    if (!Array.from(Matter.Sizes.keys()).includes(hard)) {
+      throw new Error("Unsupported code " + hard);
+    }
+    var sizage = Matter.Sizes.get(hard);
+    var cs = sizage.hs + sizage.ss;
+    var size = -1;
+    if (sizage.fs == -1) {
+      // Variable size code, Not supported
+      throw new Error("Variable size codes not supported yet");
+    } else {
+      size = sizage.fs;
+    }
+    if (qb64.length < sizage.fs) {
+      throw new Error("Need " + (sizage.fs - qb64.length) + " more chars.");
+    }
+    qb64 = qb64.slice(0, sizage.fs);
+    var ps = cs % 4;
+    var pbs = 2 * (ps == 0 ? sizage.ls : ps);
+    var raw;
+    if (ps != 0) {
+      var base = new Array(ps + 1).join('A') + qb64.slice(cs);
+      var paw = Base64.decode(base); // decode base to leave prepadded raw
+      var pi = readInt(paw.subarray(0, ps)); // prepad as int
+      if (pi & Math.pow(2, pbs) - 1) {
+        // masked pad bits non-zero
+        throw new Error("Non zeroed prepad bits = {pi & (2 ** pbs - 1 ):<06b} in {qb64b[cs:cs+1]}.");
+      }
+      raw = paw.subarray(ps); // strip off ps prepad paw bytes
+    } else {
+      var _base = qb64.slice(cs);
+      var _paw = Base64.decode(_base);
+      var li = readInt(_paw.subarray(0, sizage.ls));
+      if (li != 0) {
+        if (li == 1) {
+          throw new Error("Non zeroed lead byte = 0x{li:02x}.");
+        } else {
+          throw new Error("Non zeroed lead bytes = 0x{li:04x}");
+        }
+      }
+      raw = _paw.subarray(sizage.ls);
+    }
+    this._code = hard; // hard only
+    this._size = size;
+    this._raw = Uint8Array.from(raw); // ensure bytes so immutable and for crypto ops
+  };
+  _proto2._bexfil = function _bexfil(qb2) {
+    throw new Error("qb2 not yet supported: " + qb2);
+  };
+  _createClass(Matter, [{
+    key: "code",
+    get: function get() {
+      return this._code;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this._size;
+    }
+  }, {
+    key: "raw",
+    get: function get() {
+      return this._raw;
+    }
+  }, {
+    key: "qb64",
+    get: function get() {
+      return this._infil();
+    }
+  }, {
+    key: "qb64b",
+    get: function get() {
+      return b(this.qb64);
+    }
+  }, {
+    key: "transferable",
+    get: function get() {
+      return !NonTransDex.has(this.code);
+    }
+  }, {
+    key: "digestive",
+    get: function get() {
+      return DigiDex.has(this.code);
+    }
+  }, {
+    key: "both",
+    get: function get() {
+      var sizage = Matter.Sizes.get(this.code);
+      return "" + this.code + intToB64(this.size, sizage.ls);
+    }
+  }]);
+  return Matter;
+}();
+Matter.Sizes = /*#__PURE__*/new Map( /*#__PURE__*/Object.entries({
+  'A': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'B': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'C': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'D': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'E': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'O': /*#__PURE__*/new Sizage(1, 0, 44, 0),
+  'P': /*#__PURE__*/new Sizage(1, 0, 124, 0),
+  "0A": /*#__PURE__*/new Sizage(2, 0, 24, 0),
+  '0B': /*#__PURE__*/new Sizage(2, 0, 88, 0),
+  '1AAH': /*#__PURE__*/new Sizage(4, 0, 100, 0)
+}));
+Matter.Hards = /*#__PURE__*/new Map([['A', 1], ['B', 1], ['C', 1], ['D', 1], ['E', 1], ['F', 1], ['G', 1], ['H', 1], ['I', 1], ['J', 1], ['K', 1], ['L', 1], ['M', 1], ['N', 1], ['O', 1], ['P', 1], ['Q', 1], ['R', 1], ['S', 1], ['T', 1], ['U', 1], ['V', 1], ['W', 1], ['X', 1], ['Y', 1], ['Z', 1], ['a', 1], ['b', 1], ['c', 1], ['d', 1], ['e', 1], ['f', 1], ['g', 1], ['h', 1], ['i', 1], ['j', 1], ['k', 1], ['l', 1], ['m', 1], ['n', 1], ['o', 1], ['p', 1], ['q', 1], ['r', 1], ['s', 1], ['t', 1], ['u', 1], ['v', 1], ['w', 1], ['x', 1], ['y', 1], ['z', 1], ['0', 2], ['1', 4], ['2', 4], ['3', 4], ['4', 2], ['5', 2], ['6', 2], ['7', 4], ['8', 4], ['9', 4]]);
+
+/**
+ * @description  Verfer :sublclass of Matter,helps to verify signature of serialization
+ *  using .raw as verifier key and .code as signature cypher suite
+ */
+var Verfer = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Verfer, _Matter);
+  function Verfer(_ref) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    _this = _Matter.call(this, {
+      raw: raw,
+      code: code,
+      qb64: qb64,
+      qb64b: qb64b,
+      qb2: qb2
+    }) || this;
+    if (Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(_this.code)) {
+      _this._verify = _this._ed25519;
+    } else {
+      throw new Error("Unsupported code = " + _this.code + " for verifier.");
+    }
+    return _this;
+  }
+  var _proto = Verfer.prototype;
+  _proto.verify = function verify(sig, ser) {
+    return this._verify(sig, ser, this.raw);
+  };
+  _proto._ed25519 = function _ed25519(sig, ser, key) {
+    try {
+      return libsodium.crypto_sign_verify_detached(sig, ser, key);
+    } catch (error) {
+      throw new Error(error);
+    }
+  };
+  return Verfer;
+}(Matter);
+
+var Cigar = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Cigar, _Matter);
+  function Cigar(_ref, verfer) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    _this = _Matter.call(this, {
+      raw: raw,
+      code: code,
+      qb64: qb64,
+      qb64b: qb64b,
+      qb2: qb2
+    }) || this;
+    _this._verfer = verfer;
+    return _this;
+  }
+  _createClass(Cigar, [{
+    key: "verfer",
+    get: function get() {
+      return this._verfer;
+    },
+    set: function set(verfer) {
+      this._verfer = verfer;
+    }
+  }]);
+  return Cigar;
+}(Matter);
+
+var IndexerCodex = function IndexerCodex() {
+  this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+  this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+  this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+  this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list.
+  this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+  this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+  this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both lists.
+  this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+  this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+  this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+  this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+  this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+};
+
+var IdrDex = /*#__PURE__*/new IndexerCodex();
+var IndexedSigCodex = /*#__PURE__*/function () {
+  function IndexedSigCodex() {
+    this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+    this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+    this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+    this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list.
+    this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+    this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+    this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both lists.
+    this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+    this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+    this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+    this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+    this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+  }
+  var _proto = IndexedSigCodex.prototype;
+  _proto.has = function has(prop) {
+    var m = new Map(Array.from(Object.entries(this), function (v) {
+      return [v[1], v[0]];
+    }));
+    return m.has(prop);
+  };
+  return IndexedSigCodex;
+}();
+var IdxSigDex = /*#__PURE__*/new IndexedSigCodex();
+var IndexedCurrentSigCodex = /*#__PURE__*/function () {
+  function IndexedCurrentSigCodex() {
+    this.Ed25519_Crt_Sig = 'B'; // Ed25519 sig appears in current list only.
+    this.ECDSA_256k1_Crt_Sig = 'D'; // ECDSA secp256k1 sig appears in current list only.
+    this.Ed448_Crt_Sig = '0B'; // Ed448 signature appears in current list only.
+    this.Ed25519_Big_Crt_Sig = '2B'; // Ed25519 sig appears in current list only.
+    this.ECDSA_256k1_Big_Crt_Sig = '2D'; // ECDSA secp256k1 sig appears in current list only.
+    this.Ed448_Big_Crt_Sig = '3B'; // Ed448 signature appears in current list only.
+  }
+  var _proto2 = IndexedCurrentSigCodex.prototype;
+  _proto2.has = function has(prop) {
+    var m = new Map(Array.from(Object.entries(this), function (v) {
+      return [v[1], v[0]];
+    }));
+    return m.has(prop);
+  };
+  return IndexedCurrentSigCodex;
+}();
+var IdxCrtSigDex = /*#__PURE__*/new IndexedCurrentSigCodex();
+var IndexedBothSigCodex = /*#__PURE__*/function () {
+  function IndexedBothSigCodex() {
+    this.Ed25519_Sig = 'A'; // Ed25519 sig appears same in both lists if any.
+    this.ECDSA_256k1_Sig = 'C'; // ECDSA secp256k1 sig appears same in both lists if any.
+    this.Ed448_Sig = '0A'; // Ed448 signature appears in both lists.
+    this.Ed25519_Big_Sig = '2A'; // Ed25519 sig appears in both listsy.
+    this.ECDSA_256k1_Big_Sig = '2C'; // ECDSA secp256k1 sig appears in both lists.
+    this.Ed448_Big_Sig = '3A'; // Ed448 signature appears in both lists.
+  }
+  var _proto3 = IndexedBothSigCodex.prototype;
+  _proto3.has = function has(prop) {
+    var m = new Map(Array.from(Object.entries(this), function (v) {
+      return [v[1], v[0]];
+    }));
+    return m.has(prop);
+  };
+  return IndexedBothSigCodex;
+}();
+var IdxBthSigDex = /*#__PURE__*/new IndexedBothSigCodex();
+var Xizage = function Xizage(hs, ss, os, fs, ls) {
+  this.hs = hs;
+  this.ss = ss;
+  this.os = os;
+  this.fs = fs;
+  this.ls = ls;
+};
+var Indexer = /*#__PURE__*/function () {
+  function Indexer(_ref) {
+    var _ref$raw = _ref.raw,
+      raw = _ref$raw === void 0 ? undefined : _ref$raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? IdrDex.Ed25519_Sig : _ref$code,
+      _ref$index = _ref.index,
+      index = _ref$index === void 0 ? 0 : _ref$index,
+      _ref$ondex = _ref.ondex,
+      ondex = _ref$ondex === void 0 ? undefined : _ref$ondex,
+      _ref$qb64b = _ref.qb64b,
+      qb64b = _ref$qb64b === void 0 ? undefined : _ref$qb64b,
+      _ref$qb = _ref.qb64,
+      qb64 = _ref$qb === void 0 ? undefined : _ref$qb,
+      _ref$qb2 = _ref.qb2,
+      qb2 = _ref$qb2 === void 0 ? undefined : _ref$qb2;
+    this.Codex = IdrDex;
+    this._code = "";
+    this._index = -1;
+    this._raw = new Uint8Array(0);
+    if (raw != undefined) {
+      if (code == undefined) {
+        throw new EmptyMaterialError("Improper initialization need either (raw and code) or qb64b or qb64 or qb2.");
+      }
+      if (!Indexer.Sizes.has(code)) {
+        throw new Error("Unsupported code=" + code + ".");
+      }
+      var xizage = Indexer.Sizes.get(code);
+      var os = xizage.os;
+      var fs = xizage.fs;
+      var cs = xizage.hs + xizage.ss;
+      var ms = xizage.ss - xizage.os;
+      if (!Number.isInteger(index) || index < 0 || index > Math.pow(64, ms) - 1) {
+        throw new Error("Invalid index=" + index + " for code=" + code + ".");
+      }
+      if (ondex != undefined && xizage.os != 0 && !(ondex >= 0 && ondex <= Math.pow(64, os) - 1)) {
+        throw new Error("Invalid ondex=" + ondex + " for code=" + code + ".");
+      }
+      if (IdxCrtSigDex.has(code) && ondex != undefined) {
+        throw new Error("Non None ondex=" + ondex + " for code=" + code + ".");
+      }
+      if (IdxBthSigDex.has(code)) {
+        if (ondex == undefined) {
+          ondex = index;
+        } else {
+          if (ondex != index && os == 0) {
+            throw new Error("Non matching ondex=" + ondex + " and index=" + index + " for code=" + code + ".");
+          }
+        }
+      }
+      if (fs == undefined) {
+        throw new Error("variable length unsupported");
+      }
+      // TODO: Don't support this code
+      //  if not fs:  # compute fs from index
+      //       if cs % 4:
+      //           raise InvalidCodeSizeError(f"Whole code size not multiple of 4 for "
+      //                                      f"variable length material. cs={cs}.")
+      //       if os != 0:
+      //           raise InvalidCodeSizeError(f"Non-zero other index size for "
+      //                                      f"variable length material. os={os}.")
+      //       fs = (index * 4) + cs
+      var rawsize = Math.floor((fs - cs) * 3 / 4);
+      raw = raw.slice(0, rawsize);
+      if (raw.length != rawsize) {
+        throw new Error("Not enougth raw bytes for code=" + code + " and index=" + index + " ,expected " + rawsize + " got " + raw.length + ".");
+      }
+      this._code = code;
+      this._index = index;
+      this._ondex = ondex;
+      this._raw = raw;
+    } else if (qb64b != undefined) {
+      var _qb = d(qb64b);
+      this._exfil(_qb);
+    } else if (qb64 != undefined) {
+      this._exfil(qb64);
+    } else if (qb2 != undefined) {
+      this._bexfil(qb2);
+    } else {
+      throw new EmptyMaterialError("Improper initialization need either (raw and code and index) or qb64b or qb64 or qb2.");
+    }
+  }
+  var _proto4 = Indexer.prototype;
+  _proto4._bexfil = function _bexfil(qb2) {
+    throw new Error("qb2 not yet supported: " + qb2);
+  };
+  Indexer._rawSize = function _rawSize(code) {
+    var xizage = Indexer.Sizes.get(code);
+    return Math.floor(xizage.fs - (xizage.hs + xizage.ss) * 3 / 4);
+  };
+  _proto4._infil = function _infil() {
+    var code = this.code;
+    var index = this.index;
+    var ondex = this.ondex;
+    var raw = this.raw;
+    var ps = (3 - raw.length % 3) % 3;
+    var xizage = Indexer.Sizes.get(code);
+    var cs = xizage.hs + xizage.ss;
+    var ms = xizage.ss - xizage.os;
+    // TODO: don't support this code
+    //  if not fs:  # compute fs from index
+    //       if cs % 4:
+    //           raise InvalidCodeSizeError(f"Whole code size not multiple of 4 for "
+    //                                      f"variable length material. cs={cs}.")
+    //       if os != 0:
+    //           raise InvalidCodeSizeError(f"Non-zero other index size for "
+    //                                      f"variable length material. os={os}.")
+    //       fs = (index * 4) + cs
+    if (index < 0 || index > Math.pow(64, ms) - 1) {
+      throw new Error("Invalid index=" + index + " for code=" + code + ".");
+    }
+    if (ondex != undefined && xizage.os != 0 && !(ondex >= 0 && ondex <= Math.pow(64, xizage.os) - 1)) {
+      throw new Error("Invalid ondex=" + ondex + " for os=" + xizage.os + " and code=" + code + ".");
+    }
+    var both = "" + code + intToB64(index, ms) + intToB64(ondex == undefined ? 0 : ondex, xizage.os);
+    if (both.length != cs) {
+      throw new Error("Mismatch code size = " + cs + " with table = " + both.length + ".");
+    }
+    if (cs % 4 != ps - xizage.ls) {
+      throw new Error("Invalid code=" + both + " for converted raw pad size=" + ps + ".");
+    }
+    var bytes = new Uint8Array(ps + raw.length);
+    for (var i = 0; i < ps; i++) {
+      bytes[i] = 0;
+    }
+    for (var _i = 0; _i < raw.length; _i++) {
+      var odx = _i + ps;
+      bytes[odx] = raw[_i];
+    }
+    var full = both + Base64.encode(buffer.Buffer.from(bytes)).slice(ps - xizage.ls);
+    if (full.length != xizage.fs) {
+      throw new Error("Invalid code=" + both + " for raw size=" + raw.length + ".");
+    }
+    return full;
+  };
+  _proto4._exfil = function _exfil(qb64) {
+    if (qb64.length == 0) {
+      throw new Error("Empty Material");
+    }
+    var first = qb64[0];
+    if (!Array.from(Indexer.Hards.keys()).includes(first)) {
+      throw new Error("Unexpected code " + first);
+    }
+    var hs = Indexer.Hards.get(first);
+    if (qb64.length < hs) {
+      throw new Error("Need " + (hs - qb64.length) + " more characters.");
+    }
+    var hard = qb64.slice(0, hs);
+    if (!Array.from(Indexer.Sizes.keys()).includes(hard)) {
+      throw new Error("Unsupported code " + hard);
+    }
+    var xizage = Indexer.Sizes.get(hard);
+    var cs = xizage.hs + xizage.ss; // both hard + soft code size
+    var ms = xizage.ss - xizage.os;
+    if (qb64.length < cs) {
+      throw new Error("Need " + (cs - qb64.length) + " more characters.");
+    }
+    var sindex = qb64.slice(hs, hs + ms);
+    var index = b64ToInt(sindex);
+    var sondex = qb64.slice(hs + ms, hs + ms + xizage.os);
+    var ondex;
+    if (IdxCrtSigDex.has(hard)) {
+      ondex = xizage.os != 0 ? b64ToInt(sondex) : undefined;
+      if (ondex != 0 && ondex != undefined) {
+        throw new Error("Invalid ondex=" + ondex + " for code=" + hard + ".");
+      } else {
+        ondex = undefined;
+      }
+    } else {
+      ondex = xizage.os != 0 ? b64ToInt(sondex) : index;
+    }
+    if (xizage.fs == undefined) {
+      throw new Error("variable length not supported");
+    }
+    // TODO: support variable length
+    // if not fs:  # compute fs from index which means variable length
+    //     if cs % 4:
+    //         raise ValidationError(f"Whole code size not multiple of 4 for "
+    //                               f"variable length material. cs={cs}.")
+    //     if os != 0:
+    //         raise ValidationError(f"Non-zero other index size for "
+    //                               f"variable length material. os={os}.")
+    //     fs = (index * 4) + cs
+    if (qb64.length < xizage.fs) {
+      throw new Error("Need " + (xizage.fs - qb64.length) + " more chars.");
+    }
+    qb64 = qb64.slice(0, xizage.fs);
+    var ps = cs % 4;
+    var pbs = 2 * ps != 0 ? ps : xizage.ls;
+    var raw;
+    if (ps != 0) {
+      var base = new Array(ps + 1).join('A') + qb64.slice(cs);
+      var paw = Base64.decode(base); // decode base to leave prepadded raw
+      var pi = readInt(paw.slice(0, ps)); // prepad as int
+      if (pi & Math.pow(2, pbs) - 1) {
+        // masked pad bits non-zero
+        throw new Error("Non zeroed prepad bits = {pi & (2 ** pbs - 1 ):<06b} in {qb64b[cs:cs+1]}.");
+      }
+      raw = paw.slice(ps); // strip off ps prepad paw bytes
+    } else {
+      var _base = qb64.slice(cs);
+      var _paw = Base64.decode(_base);
+      var li = readInt(_paw.slice(0, xizage.ls));
+      if (li != 0) {
+        if (li == 1) {
+          throw new Error("Non zeroed lead byte = 0x{li:02x}.");
+        } else {
+          throw new Error("Non zeroed lead bytes = 0x{li:04x}");
+        }
+      }
+      raw = _paw.slice(xizage.ls);
+    }
+    if (raw.length != Math.floor((qb64.length - cs) * 3 / 4)) {
+      throw new Error("Improperly qualified material = " + qb64);
+    }
+    this._code = hard;
+    this._index = index;
+    this._ondex = ondex;
+    this._raw = new Uint8Array(raw); // must be bytes for crpto opts and immutable not bytearray
+  };
+  _createClass(Indexer, [{
+    key: "code",
+    get: function get() {
+      return this._code;
+    }
+  }, {
+    key: "raw",
+    get: function get() {
+      return this._raw;
+    }
+  }, {
+    key: "index",
+    get: function get() {
+      return this._index;
+    }
+  }, {
+    key: "ondex",
+    get: function get() {
+      return this._ondex;
+    }
+  }, {
+    key: "qb64",
+    get: function get() {
+      return this._infil();
+    }
+  }, {
+    key: "qb64b",
+    get: function get() {
+      return b(this.qb64);
+    }
+  }]);
+  return Indexer;
+}();
+Indexer.Hards = /*#__PURE__*/new Map([['A', 1], ['B', 1], ['C', 1], ['D', 1], ['E', 1], ['F', 1], ['G', 1], ['H', 1], ['I', 1], ['J', 1], ['K', 1], ['L', 1], ['M', 1], ['N', 1], ['O', 1], ['P', 1], ['Q', 1], ['R', 1], ['S', 1], ['T', 1], ['U', 1], ['V', 1], ['W', 1], ['X', 1], ['Y', 1], ['Z', 1], ['a', 1], ['b', 1], ['c', 1], ['d', 1], ['e', 1], ['f', 1], ['g', 1], ['h', 1], ['i', 1], ['j', 1], ['k', 1], ['l', 1], ['m', 1], ['n', 1], ['o', 1], ['p', 1], ['q', 1], ['r', 1], ['s', 1], ['t', 1], ['u', 1], ['v', 1], ['w', 1], ['x', 1], ['y', 1], ['z', 1], ['0', 2], ['1', 2], ['2', 2], ['3', 2], ['4', 2]]);
+Indexer.Sizes = /*#__PURE__*/new Map( /*#__PURE__*/Object.entries({
+  'A': /*#__PURE__*/new Xizage(1, 1, 0, 88, 0),
+  'B': /*#__PURE__*/new Xizage(1, 1, 0, 88, 0),
+  'C': /*#__PURE__*/new Xizage(1, 1, 0, 88, 0),
+  'D': /*#__PURE__*/new Xizage(1, 1, 0, 88, 0),
+  '0A': /*#__PURE__*/new Xizage(2, 2, 1, 156, 0),
+  '0B': /*#__PURE__*/new Xizage(2, 2, 1, 156, 0),
+  '2A': /*#__PURE__*/new Xizage(2, 4, 2, 92, 0),
+  '2B': /*#__PURE__*/new Xizage(2, 4, 2, 92, 0),
+  '2C': /*#__PURE__*/new Xizage(2, 4, 2, 92, 0),
+  '2D': /*#__PURE__*/new Xizage(2, 4, 2, 92, 0),
+  '3A': /*#__PURE__*/new Xizage(2, 6, 3, 160, 0),
+  '3B': /*#__PURE__*/new Xizage(2, 6, 3, 160, 0),
+  '0z': /*#__PURE__*/new Xizage(2, 2, 0, undefined, 0),
+  '1z': /*#__PURE__*/new Xizage(2, 2, 1, 76, 1),
+  '4z': /*#__PURE__*/new Xizage(2, 6, 3, 80, 1)
+}));
+
+/**
+   Siger is subclass of Indexer, indexed signature material,
+    Adds .verfer property which is instance of Verfer that provides
+          associated signature verifier.
+
+    See Indexer for inherited attributes and properties:
+
+    Attributes:
+
+    Properties:
+        .verfer is Verfer object instance
+
+    Methods:
+ **/
+var Siger = /*#__PURE__*/function (_Indexer) {
+  _inheritsLoose(Siger, _Indexer);
+  function Siger(_ref, verfer) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      index = _ref.index,
+      ondex = _ref.ondex,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    _this = _Indexer.call(this, {
+      raw: raw,
+      code: code,
+      index: index,
+      ondex: ondex,
+      qb64: qb64,
+      qb64b: qb64b,
+      qb2: qb2
+    }) || this;
+    if (!IdxSigDex.has(_this.code)) {
+      throw new Error("Invalid code = " + _this.code + " for Siger.");
+    }
+    _this._verfer = verfer;
+    return _this;
+  }
+  _createClass(Siger, [{
+    key: "verfer",
+    get: function get() {
+      return this._verfer;
+    },
+    set: function set(verfer) {
+      this._verfer = verfer;
+    }
+  }]);
+  return Siger;
+}(Indexer);
+
+var Signer = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Signer, _Matter);
+  function Signer(_ref) {
+    var _this;
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.Ed25519_Seed : _ref$code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2,
+      _ref$transferable = _ref.transferable,
+      transferable = _ref$transferable === void 0 ? true : _ref$transferable;
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64: qb64,
+        qb64b: qb64b,
+        qb2: qb2
+      }) || this;
+    } catch (e) {
+      if (e instanceof EmptyMaterialError) {
+        if (code == MtrDex.Ed25519_Seed) {
+          var _raw = libsodium.randombytes_buf(libsodium.crypto_sign_SEEDBYTES);
+          _this = _Matter.call(this, {
+            raw: _raw,
+            code: code,
+            qb64: qb64,
+            qb64b: qb64b,
+            qb2: qb2
+          }) || this;
+        } else {
+          throw new Error("Unsupported signer code = " + code + ".");
+        }
+      } else {
+        throw e;
+      }
+    }
+    var verfer;
+    if (_this.code == MtrDex.Ed25519_Seed) {
+      _this._sign = _this._ed25519;
+      var keypair = libsodium.crypto_sign_seed_keypair(_this.raw);
+      verfer = new Verfer({
+        raw: keypair.publicKey,
+        code: transferable ? MtrDex.Ed25519 : MtrDex.Ed25519N
+      });
+    } else {
+      throw new Error("Unsupported signer code = " + _this.code + ".");
+    }
+    _this._verfer = verfer;
+    return _assertThisInitialized(_this);
+  }
+  /**
+   * @description Property verfer:
+   Returns Verfer instance
+   Assumes ._verfer is correctly assigned
+   */
+  var _proto = Signer.prototype;
+  _proto.sign = function sign(ser, index, only, ondex) {
+    if (index === void 0) {
+      index = null;
+    }
+    if (only === void 0) {
+      only = false;
+    }
+    if (ondex === void 0) {
+      ondex = undefined;
+    }
+    return this._sign(ser, this.raw, this.verfer, index, only, ondex);
+  };
+  _proto._ed25519 = function _ed25519(ser, seed, verfer, index, only, ondex) {
+    if (only === void 0) {
+      only = false;
+    }
+    var sig = libsodium.crypto_sign_detached(ser, buffer.Buffer.concat([seed, verfer.raw]));
+    if (index == null) {
+      return new Cigar({
+        raw: sig,
+        code: MtrDex.Ed25519_Sig
+      }, verfer);
+    } else {
+      var code;
+      if (only) {
+        ondex = undefined;
+        if (index <= 63) {
+          code = IdrDex.Ed25519_Crt_Sig;
+        } else {
+          code = IdrDex.Ed25519_Big_Crt_Sig;
+        }
+      } else {
+        if (ondex == undefined) {
+          ondex = index;
+        }
+        if (ondex == index && index <= 63)
+          // both same and small
+          code = IdrDex.Ed25519_Sig; //  use  small both same
+        else
+          //  otherwise big or both not same so use big both
+          code = IdrDex.Ed25519_Big_Sig; // use use big both
+      }
+
+      return new Siger({
+        raw: sig,
+        code: code,
+        index: index,
+        ondex: ondex
+      }, verfer);
+    }
+  };
+  _createClass(Signer, [{
+    key: "verfer",
+    get: function get() {
+      return this._verfer;
+    }
+  }]);
+  return Signer;
+}(Matter);
+
+var Salter = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Salter, _Matter);
+  function Salter(_ref) {
+    var _this;
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.Salt_128 : _ref$code,
+      _ref$tier = _ref.tier,
+      tier = _ref$tier === void 0 ? "low" : _ref$tier,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64: qb64,
+        qb64b: qb64b,
+        qb2: qb2
+      }) || this;
+    } catch (e) {
+      if (e instanceof EmptyMaterialError) {
+        if (code == MtrDex.Salt_128) {
+          var salt = libsodium.randombytes_buf(libsodium.crypto_pwhash_SALTBYTES);
+          _this = _Matter.call(this, {
+            raw: salt,
+            code: code
+          }) || this;
+        } else {
+          throw new Error("invalid code for Salter, only Salt_128 accepted");
+        }
+      } else {
+        throw e;
+      }
+    }
+    if (_this.code != MtrDex.Salt_128) {
+      throw new Error("invalid code for Salter, only Salt_128 accepted");
+    }
+    _this._tier = tier !== null ? tier : "low" /* low */;
+    return _assertThisInitialized(_this);
+  }
+  var _proto = Salter.prototype;
+  _proto.stretch = function stretch(size, path, tier, temp) {
+    if (size === void 0) {
+      size = 32;
+    }
+    if (path === void 0) {
+      path = "";
+    }
+    if (tier === void 0) {
+      tier = null;
+    }
+    if (temp === void 0) {
+      temp = false;
+    }
+    tier = tier == null ? this.tier : tier;
+    var opslimit, memlimit;
+    if (temp) {
+      opslimit = libsodium.crypto_pwhash_OPSLIMIT_MIN;
+      memlimit = libsodium.crypto_pwhash_MEMLIMIT_MIN;
+    } else {
+      switch (tier) {
+        case "low" /* low */:
+          opslimit = libsodium.crypto_pwhash_OPSLIMIT_INTERACTIVE;
+          memlimit = libsodium.crypto_pwhash_MEMLIMIT_INTERACTIVE;
+          break;
+        case "med" /* med */:
+          opslimit = libsodium.crypto_pwhash_OPSLIMIT_MODERATE;
+          memlimit = libsodium.crypto_pwhash_MEMLIMIT_MODERATE;
+          break;
+        case "high" /* high */:
+          opslimit = libsodium.crypto_pwhash_OPSLIMIT_SENSITIVE;
+          memlimit = libsodium.crypto_pwhash_MEMLIMIT_SENSITIVE;
+          break;
+        default:
+          throw new Error("Unsupported security tier = " + tier + ".");
+      }
+    }
+    return libsodium.crypto_pwhash(size, path, this.raw, opslimit, memlimit, libsodium.crypto_pwhash_ALG_DEFAULT);
+  };
+  _proto.signer = function signer(code, transferable, path, tier, temp) {
+    if (code === void 0) {
+      code = MtrDex.Ed25519_Seed;
+    }
+    if (transferable === void 0) {
+      transferable = true;
+    }
+    if (path === void 0) {
+      path = "";
+    }
+    if (tier === void 0) {
+      tier = null;
+    }
+    if (temp === void 0) {
+      temp = false;
+    }
+    var seed = this.stretch(Matter._rawSize(code), path, tier, temp);
+    return new Signer({
+      raw: seed,
+      code: code,
+      transferable: transferable
+    });
+  };
+  _createClass(Salter, [{
+    key: "tier",
+    get: function get() {
+      return this._tier;
+    }
+  }]);
+  return Salter;
+}(Matter);
+
+var Decrypter = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Decrypter, _Matter);
+  function Decrypter(_ref, seed) {
+    var _this;
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.X25519_Private : _ref$code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    if (seed === void 0) {
+      seed = undefined;
+    }
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64: qb64,
+        qb64b: qb64b,
+        qb2: qb2
+      }) || this;
+    } catch (e) {
+      if (e instanceof EmptyMaterialError) {
+        if (seed != undefined) {
+          var signer = new Signer({
+            qb64b: seed
+          });
+          if (signer.code != MtrDex.Ed25519_Seed) {
+            throw new Error("Unsupported signing seed derivation code " + signer.code);
+          }
+          var sigkey = new Uint8Array(signer.raw.length + signer.verfer.raw.length);
+          sigkey.set(signer.raw);
+          sigkey.set(signer.verfer.raw, signer.raw.length);
+          raw = libsodium.crypto_sign_ed25519_sk_to_curve25519(sigkey);
+          _this = _Matter.call(this, {
+            raw: raw,
+            code: code,
+            qb64: qb64,
+            qb64b: qb64b,
+            qb2: qb2
+          }) || this;
+        } else {
+          throw e;
+        }
+      } else {
+        throw e;
+      }
+    }
+    if (_this.code == MtrDex.X25519_Private) {
+      _this._decrypt = _this._x25519;
+    } else {
+      throw new Error("Unsupported decrypter code = " + _this.code + ".");
+    }
+    return _assertThisInitialized(_this);
   }
-  return a + b;
+  var _proto = Decrypter.prototype;
+  _proto.decrypt = function decrypt(ser, cipher, transferable) {
+    if (ser === void 0) {
+      ser = null;
+    }
+    if (cipher === void 0) {
+      cipher = null;
+    }
+    if (transferable === void 0) {
+      transferable = false;
+    }
+    if (ser == null && cipher == null) {
+      throw new EmptyMaterialError("Neither ser or cipher were provided");
+    }
+    if (ser != null) {
+      cipher = new Cipher({
+        qb64b: ser
+      });
+    }
+    return this._decrypt(cipher, this.raw, transferable);
+  };
+  _proto._x25519 = function _x25519(cipher, prikey, transferable) {
+    if (transferable === void 0) {
+      transferable = false;
+    }
+    var pubkey = libsodium.crypto_scalarmult_base(prikey);
+    var plain = libsodium.crypto_box_seal_open(cipher.raw, pubkey, prikey);
+    if (cipher.code == MtrDex.X25519_Cipher_Salt) {
+      return new Salter({
+        qb64b: plain
+      });
+    } else if (cipher.code == MtrDex.X25519_Cipher_Seed) {
+      return new Signer({
+        qb64b: plain,
+        transferable: transferable
+      });
+    } else {
+      throw new Error("Unsupported cipher text code == " + cipher.code);
+    }
+  };
+  return Decrypter;
+}(Matter);
+
+var Cipher = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Cipher, _Matter);
+  function Cipher(_ref) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    if (raw != undefined && code == undefined) {
+      if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Salt)) {
+        code = MtrDex.X25519_Cipher_Salt;
+      } else if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)) {
+        code = MtrDex.X25519_Cipher_Salt;
+      }
+    }
+    _this = _Matter.call(this, {
+      raw: raw,
+      code: code,
+      qb64b: qb64b,
+      qb64: qb64,
+      qb2: qb2
+    }) || this;
+    if (!Array.from([MtrDex.X25519_Cipher_Salt, MtrDex.X25519_Cipher_Seed]).includes(_this.code)) {
+      throw new Error("Unsupported Cipher code == " + _this.code);
+    }
+    return _this;
+  }
+  var _proto = Cipher.prototype;
+  _proto.decrypt = function decrypt(prikey, seed) {
+    if (prikey === void 0) {
+      prikey = undefined;
+    }
+    if (seed === void 0) {
+      seed = undefined;
+    }
+    var decrypter = new Decrypter({
+      qb64b: prikey
+    }, seed);
+    return decrypter.decrypt(this.qb64b);
+  };
+  return Cipher;
+}(Matter);
+
+function arrayEquals(ar1, ar2) {
+  return ar1.length === ar2.length && ar1.every(function (val, index) {
+    return val === ar2[index];
+  });
+}
+
+var Encrypter = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Encrypter, _Matter);
+  function Encrypter(_ref, verkey) {
+    var _this;
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.X25519 : _ref$code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    if (verkey === void 0) {
+      verkey = null;
+    }
+    if (raw == undefined && verkey != null) {
+      var verfer = new Verfer({
+        qb64b: verkey
+      });
+      if (!Array.from([MtrDex.Ed25519N, MtrDex.Ed25519]).includes(verfer.code)) {
+        throw new Error("Unsupported verkey derivation code = " + verfer.code + ".");
+      }
+      raw = libsodium.crypto_sign_ed25519_pk_to_curve25519(verfer.raw);
+    }
+    _this = _Matter.call(this, {
+      raw: raw,
+      code: code,
+      qb64: qb64,
+      qb64b: qb64b,
+      qb2: qb2
+    }) || this;
+    if (_this.code == MtrDex.X25519) {
+      _this._encrypt = _this._x25519;
+    } else {
+      throw new Error("Unsupported encrypter code = " + _this.code + ".");
+    }
+    return _this;
+  }
+  var _proto = Encrypter.prototype;
+  _proto.verifySeed = function verifySeed(seed) {
+    var signer = new Signer({
+      qb64b: seed
+    });
+    var keypair = libsodium.crypto_sign_seed_keypair(signer.raw);
+    var pubkey = libsodium.crypto_sign_ed25519_pk_to_curve25519(keypair.publicKey);
+    return arrayEquals(pubkey, this.raw);
+  };
+  _proto.encrypt = function encrypt(ser, matter) {
+    if (ser === void 0) {
+      ser = null;
+    }
+    if (matter === void 0) {
+      matter = null;
+    }
+    if (ser == null && matter == null) {
+      throw new Error("Neither ser nor matter are provided.");
+    }
+    if (ser != null) {
+      matter = new Matter({
+        qb64b: ser
+      });
+    }
+    var code;
+    if (matter.code == MtrDex.Salt_128) {
+      code = MtrDex.X25519_Cipher_Salt;
+    } else {
+      code = MtrDex.X25519_Cipher_Seed;
+    }
+    return this._encrypt(matter.qb64, this.raw, code);
+  };
+  _proto._x25519 = function _x25519(ser, pubkey, code) {
+    var raw = libsodium.crypto_box_seal(ser, pubkey);
+    return new Cipher({
+      raw: raw,
+      code: code
+    });
+  };
+  return Encrypter;
+}(Matter);
+
+/**
+ * @description : Diger is subset of Matter and is used to verify the digest of serialization
+ * It uses  .raw : as digest
+ * .code as digest algorithm
+ *
+ */
+var Diger = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Diger, _Matter);
+  // This constructor will assign digest verification function to ._verify
+  function Diger(_ref, ser) {
+    var _this;
+    var raw = _ref.raw,
+      _ref$code = _ref.code,
+      code = _ref$code === void 0 ? MtrDex.Blake3_256 : _ref$code,
+      qb64 = _ref.qb64,
+      qb64b = _ref.qb64b,
+      qb2 = _ref.qb2;
+    if (ser === void 0) {
+      ser = null;
+    }
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64: qb64,
+        qb64b: qb64b,
+        qb2: qb2
+      }) || this;
+    } catch (error) {
+      if (ser == null) {
+        throw error;
+      }
+      if (code === MtrDex.Blake3_256) {
+        var hasher = blake3.createHash();
+        var dig = hasher.update(ser).digest('');
+        _this = _Matter.call(this, {
+          raw: dig,
+          code: code
+        }) || this;
+      } else {
+        throw new Error("Unsupported code = " + code + " for digester.");
+      }
+    }
+    if (code === MtrDex.Blake3_256) {
+      _this._verify = _this.blake3_256;
+    } else {
+      throw new Error("Unsupported code = " + code + " for digester.");
+    }
+    return _assertThisInitialized(_this);
+  }
+  /**
+   *
+   * @param {Uint8Array} ser  serialization bytes
+   * @description  This method will return true if digest of bytes serialization ser matches .raw
+   * using .raw as reference digest for ._verify digest algorithm determined
+   by .code
+   */
+  var _proto = Diger.prototype;
+  _proto.verify = function verify(ser) {
+    return this._verify(ser, this.raw);
+  };
+  _proto.compare = function compare(ser, dig, diger) {
+    if (dig === void 0) {
+      dig = null;
+    }
+    if (diger === void 0) {
+      diger = null;
+    }
+    if (dig != null) {
+      if (dig.toString() == this.qb64) {
+        return true;
+      }
+      diger = new Diger({
+        qb64b: dig
+      });
+    } else if (diger != null) {
+      if (diger.qb64b == this.qb64b) {
+        return true;
+      }
+    } else {
+      throw new Error("Both dig and diger may not be None.");
+    }
+    if (diger.code == this.code) {
+      return false;
+    }
+    return diger.verify(ser) && this.verify(ser);
+  };
+  _proto.blake3_256 = function blake3_256(ser, dig) {
+    var hasher = blake3.createHash();
+    var digest = hasher.update(ser).digest('');
+    return digest.toString() === dig.toString();
+  };
+  return Diger;
+}(Matter);
+
+var Algos;
+(function (Algos) {
+  Algos["randy"] = "randy";
+  Algos["salty"] = "salty";
+})(Algos || (Algos = {}));
+var PubLot = function PubLot() {
+  this.pubs = new Array(); // list qb64 public keys.
+  this.ridx = 0; //  index of rotation (est event) that uses public key set
+  this.kidx = 0; //  index of key in sequence of public keys
+  this.dt = ""; // datetime ISO8601 when key set created
+};
+var PreSit = function PreSit() {
+  this.old = new PubLot(); //previous publot
+  this["new"] = new PubLot(); //newly current publot
+  this.nxt = new PubLot(); //next public publot
+};
+var PrePrm = function PrePrm() {
+  this.pidx = 0; // prefix index for this keypair sequence
+  this.algo = Algos.salty; // salty default uses indices and salt to create new key pairs
+  this.salt = ''; // empty salt  used for salty algo.
+  this.stem = ''; // default unique path stem for salty algo
+  this.tier = ''; // security tier for stretch index salty algo
+};
+var PubSet = function PubSet() {
+  this.pubs = new Array(); // list qb64 public keys.
+};
+var PubPath = function PubPath() {
+  this.path = "";
+  this.code = "";
+  this.tier = "high" /* high */;
+  this.temp = false;
+};
+var Keys = /*#__PURE__*/function () {
+  function Keys(signers, paths) {
+    this._signers = signers;
+    if (paths != undefined) {
+      if (signers.length != paths.length) {
+        throw new Error("If paths are provided, they must be the same length as signers");
+      }
+    }
+    this._paths = paths;
+  }
+  _createClass(Keys, [{
+    key: "paths",
+    get: function get() {
+      return this._paths;
+    }
+  }, {
+    key: "signers",
+    get: function get() {
+      return this._signers;
+    }
+  }]);
+  return Keys;
+}();
+var RandyCreator = /*#__PURE__*/function () {
+  function RandyCreator() {}
+  var _proto = RandyCreator.prototype;
+  _proto.create = function create(codes, count, code, transferable) {
+    if (codes === void 0) {
+      codes = undefined;
+    }
+    if (count === void 0) {
+      count = 1;
+    }
+    if (code === void 0) {
+      code = MtrDex.Ed25519_Seed;
+    }
+    if (transferable === void 0) {
+      transferable = true;
+    }
+    var signers = new Array();
+    if (codes == undefined) {
+      codes = new Array(count).fill(code);
+    }
+    codes.forEach(function (code) {
+      signers.push(new Signer({
+        code: code,
+        transferable: transferable
+      }));
+    });
+    return new Keys(signers);
+  };
+  _createClass(RandyCreator, [{
+    key: "salt",
+    get: function get() {
+      return "";
+    }
+  }, {
+    key: "stem",
+    get: function get() {
+      return "";
+    }
+  }, {
+    key: "tier",
+    get: function get() {
+      return "";
+    }
+  }]);
+  return RandyCreator;
+}();
+var SaltyCreator = /*#__PURE__*/function () {
+  function SaltyCreator(salt, tier, stem) {
+    if (salt === void 0) {
+      salt = undefined;
+    }
+    if (tier === void 0) {
+      tier = undefined;
+    }
+    if (stem === void 0) {
+      stem = undefined;
+    }
+    this.salter = new Salter({
+      qb64: salt,
+      tier: tier
+    });
+    this._stem = stem == undefined ? "" : stem;
+  }
+  var _proto2 = SaltyCreator.prototype;
+  _proto2.create = function create(codes, count, code, transferable, pidx, ridx, kidx, temp) {
+    var _this = this;
+    if (codes === void 0) {
+      codes = undefined;
+    }
+    if (count === void 0) {
+      count = 1;
+    }
+    if (code === void 0) {
+      code = MtrDex.Ed25519_Seed;
+    }
+    if (transferable === void 0) {
+      transferable = true;
+    }
+    if (pidx === void 0) {
+      pidx = 0;
+    }
+    if (ridx === void 0) {
+      ridx = 0;
+    }
+    if (kidx === void 0) {
+      kidx = 0;
+    }
+    if (temp === void 0) {
+      temp = false;
+    }
+    var signers = new Array();
+    var paths = new Array();
+    if (codes == undefined) {
+      codes = new Array(count).fill(code);
+    }
+    codes.forEach(function (code, idx) {
+      var path = _this.stem + pidx.toString(16) + ridx.toString(16) + (kidx + idx).toString(16);
+      signers.push(_this.salter.signer(code, transferable, path, _this.tier, temp));
+      paths.push(path);
+    });
+    return new Keys(signers, paths);
+  };
+  _createClass(SaltyCreator, [{
+    key: "salt",
+    get: function get() {
+      return this.salter.qb64;
+    }
+  }, {
+    key: "stem",
+    get: function get() {
+      return this._stem;
+    }
+  }, {
+    key: "tier",
+    get: function get() {
+      return this.salter.tier;
+    }
+  }]);
+  return SaltyCreator;
+}();
+var Creatory = /*#__PURE__*/function () {
+  function Creatory(algo) {
+    if (algo === void 0) {
+      algo = Algos.salty;
+    }
+    switch (algo) {
+      case Algos.randy:
+        this._make = this._makeRandy;
+        break;
+      case Algos.salty:
+        this._make = this._makeSalty;
+        break;
+      default:
+        throw new Error("unsupported algo=" + algo);
+    }
+  }
+  var _proto3 = Creatory.prototype;
+  _proto3.make = function make() {
+    return this._make.apply(this, arguments);
+  };
+  _proto3._makeRandy = function _makeRandy() {
+    return new RandyCreator();
+  };
+  _proto3._makeSalty = function _makeSalty() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _construct(SaltyCreator, args);
+  };
+  return Creatory;
+}();
+var Manager = /*#__PURE__*/function () {
+  function Manager(_ref) {
+    var ks = _ref.ks,
+      seed = _ref.seed,
+      aeid = _ref.aeid,
+      pidx = _ref.pidx,
+      algo = _ref.algo,
+      salt = _ref.salt,
+      tier = _ref.tier;
+    this._ks = ks == undefined ? new Keeper() : ks;
+    this._seed = seed;
+    this._encrypter = undefined;
+    this._decrypter = undefined;
+    aeid = aeid == undefined ? undefined : aeid;
+    pidx = pidx == undefined ? 0 : pidx;
+    algo = algo == undefined ? Algos.salty : algo;
+    if (salt == undefined) {
+      salt = new Salter({}).qb64;
+    } else {
+      if (new Salter({
+        qb64: salt
+      }).qb64 != salt) {
+        throw new Error("Invalid qb64 for salt=" + salt + ".");
+      }
+    }
+    tier = tier == undefined ? "low" /* low */ : tier;
+    if (this.pidx == undefined) {
+      this.pidx = pidx;
+    }
+    if (this.algo == undefined) {
+      this.algo = algo;
+    }
+    if (this.salt == undefined) {
+      this.salt = salt;
+    }
+    if (this.tier == undefined) {
+      this.tier = tier;
+    }
+    if (this.aeid == undefined) {
+      this.updateAeid(aeid, this._seed);
+    }
+  }
+  var _proto4 = Manager.prototype;
+  _proto4.updateAeid = function updateAeid(aeid, seed) {
+    if (this.aeid != undefined) {
+      var _this$_encrypter;
+      var _seed = b(this._seed);
+      if (this._seed == undefined || !((_this$_encrypter = this._encrypter) != null && _this$_encrypter.verifySeed(_seed))) {
+        throw new Error("Last seed missing or provided last seed \"\n                                       \"not associated with last aeid=" + this.aeid + ".");
+      }
+    }
+    if (aeid != "" && aeid != undefined) {
+      if (aeid != this.aeid) {
+        this._encrypter = new Encrypter({}, b(aeid));
+        if (seed == undefined || !this._encrypter.verifySeed(b(seed))) {
+          throw new Error("Seed missing or provided seed not associated\"\n                                           \"  with provided aeid=" + aeid + ".");
+        }
+      }
+    } else if (this.algo == Algos.randy) {
+      // Unlike KERIpy, we don't support unencrypted secrets
+      throw new Error("Invalid Manager configuration, encryption must be used with Randy key creation.");
+    } else {
+      this._encrypter = undefined;
+    }
+    var salt = this.salt;
+    if (salt != undefined) {
+      this.salt = salt;
+    }
+    if (this._decrypter != undefined) {
+      for (var _iterator = _createForOfIteratorHelperLoose(this.ks.prmsElements()), _step; !(_step = _iterator()).done;) {
+        var _step$value = _step.value,
+          keys = _step$value[0],
+          data = _step$value[1];
+        if (data.salt != undefined) {
+          var salter = this._decrypter.decrypt(b(data.salt));
+          data.salt = this._encrypter == undefined ? salter.qb64 : this._encrypter.encrypt(null, salter);
+          this.ks.pinPrms(keys, data);
+        }
+      }
+      for (var _iterator2 = _createForOfIteratorHelperLoose(this.ks.prisElements(this._decrypter)), _step2; !(_step2 = _iterator2()).done;) {
+        var _step2$value = _step2.value,
+          pubKey = _step2$value[0],
+          signer = _step2$value[1];
+        this.ks.pinPris(pubKey, signer, this._encrypter);
+      }
+    }
+    this.ks.pinGbls("aeid", aeid); // set aeid in db
+    this._seed = seed; // set .seed in memory
+    // update .decrypter
+    this._decrypter = seed != undefined ? new Decrypter({}, b(seed)) : undefined;
+  };
+  _proto4.incept = function incept(_ref2) {
+    var _this2 = this;
+    var _ref2$icodes = _ref2.icodes,
+      icodes = _ref2$icodes === void 0 ? undefined : _ref2$icodes,
+      _ref2$icount = _ref2.icount,
+      icount = _ref2$icount === void 0 ? 1 : _ref2$icount,
+      _ref2$icode = _ref2.icode,
+      icode = _ref2$icode === void 0 ? MtrDex.Ed25519_Seed : _ref2$icode,
+      _ref2$ncodes = _ref2.ncodes,
+      ncodes = _ref2$ncodes === void 0 ? undefined : _ref2$ncodes,
+      _ref2$ncount = _ref2.ncount,
+      ncount = _ref2$ncount === void 0 ? 1 : _ref2$ncount,
+      _ref2$ncode = _ref2.ncode,
+      ncode = _ref2$ncode === void 0 ? MtrDex.Ed25519_Seed : _ref2$ncode,
+      _ref2$dcode = _ref2.dcode,
+      dcode = _ref2$dcode === void 0 ? MtrDex.Blake3_256 : _ref2$dcode,
+      _ref2$algo = _ref2.algo,
+      algo = _ref2$algo === void 0 ? undefined : _ref2$algo,
+      _ref2$salt = _ref2.salt,
+      salt = _ref2$salt === void 0 ? undefined : _ref2$salt,
+      _ref2$stem = _ref2.stem,
+      stem = _ref2$stem === void 0 ? undefined : _ref2$stem,
+      _ref2$tier = _ref2.tier,
+      tier = _ref2$tier === void 0 ? undefined : _ref2$tier,
+      _ref2$rooted = _ref2.rooted,
+      rooted = _ref2$rooted === void 0 ? true : _ref2$rooted,
+      _ref2$transferable = _ref2.transferable,
+      transferable = _ref2$transferable === void 0 ? true : _ref2$transferable,
+      _ref2$temp = _ref2.temp,
+      temp = _ref2$temp === void 0 ? false : _ref2$temp;
+    if (rooted && algo == undefined) {
+      algo = this.algo;
+    }
+    if (rooted && salt == undefined) {
+      salt = this.salt;
+    }
+    if (rooted && tier == undefined) {
+      tier = this.tier;
+    }
+    var pidx = this.pidx;
+    var ridx = 0;
+    var kidx = 0;
+    var creator = new Creatory(algo).make(salt, tier, stem);
+    if (icodes == undefined) {
+      if (icount < 0) {
+        throw new Error("Invalid icount=" + icount + " must be >= 0.");
+      }
+      icodes = new Array(icount).fill(icode);
+    }
+    var ikeys = creator.create(icodes, 0, MtrDex.Ed25519_Seed, transferable, pidx, ridx, kidx, temp);
+    var verfers = Array.from(ikeys.signers, function (signer) {
+      return signer.verfer;
+    });
+    if (ncodes == undefined) {
+      if (ncount < 0) {
+        throw new Error("Invalid ncount=" + ncount + " must be >= 0.");
+      }
+      ncodes = new Array(ncount).fill(ncode);
+    }
+    var nkeys = creator.create(ncodes, 0, MtrDex.Ed25519_Seed, transferable, pidx, ridx + 1, kidx + icodes.length, temp);
+    var digers = Array.from(nkeys.signers, function (signer) {
+      return new Diger({
+        code: dcode
+      }, signer.verfer.qb64b);
+    });
+    var pp = new PrePrm();
+    pp.pidx = pidx;
+    pp.algo = algo;
+    pp.salt = creator.salt.length == 0 || this.encrypter == undefined ? "" : this.encrypter.encrypt(b(creator.salt)).qb64;
+    pp.stem = creator.stem;
+    pp.tier = creator.tier;
+    var dt = new Date().toString();
+    var nw = new PubLot();
+    nw.pubs = Array.from(verfers, function (verfer) {
+      return verfer.qb64;
+    });
+    nw.ridx = ridx;
+    nw.kidx = kidx;
+    nw.dt = dt;
+    var nt = new PubLot();
+    nt.pubs = Array.from(nkeys.signers, function (signer) {
+      return signer.verfer.qb64;
+    });
+    nt.ridx = ridx + 1;
+    nt.kidx = kidx + icodes.length;
+    nt.dt = dt;
+    var ps = new PreSit();
+    ps["new"] = nw;
+    ps.nxt = nt;
+    var pre = verfers[0].qb64;
+    if (!this.ks.putPres(pre, verfers[0].qb64b)) {
+      throw new Error("Already incepted pre=" + pre + ".");
+    }
+    if (!this.ks.putPrms(pre, pp)) {
+      throw new Error("Already incepted prm for pre=" + pre + ".");
+    }
+    this.pidx = pidx + 1;
+    if (!this.ks.putSits(pre, ps)) {
+      throw new Error("Already incepted sit for pre=" + pre + ".");
+    }
+    if (this.encrypter != undefined) {
+      // Only store encrypted keys if we have an encrypter, otherwise regenerate
+      ikeys.signers.forEach(function (signer) {
+        _this2.ks.putPris(signer.verfer.qb64, signer, _this2.encrypter);
+      });
+      nkeys.signers.forEach(function (signer) {
+        _this2.ks.putPris(signer.verfer.qb64, signer, _this2.encrypter);
+      });
+    } else if (this._encrypter == undefined && ikeys.paths != undefined && nkeys.paths != undefined) {
+      ikeys.paths.forEach(function (path, idx) {
+        var signer = ikeys.signers[idx];
+        var ppt = new PubPath();
+        ppt.path = path;
+        ppt.code = icodes[idx];
+        ppt.tier = pp.tier;
+        ppt.temp = temp;
+        _this2.ks.putPths(signer.verfer.qb64, ppt);
+      });
+      nkeys.paths.forEach(function (path, idx) {
+        var signer = nkeys.signers[idx];
+        var ppt = new PubPath();
+        ppt.path = path;
+        ppt.code = ncodes[idx];
+        ppt.tier = pp.tier;
+        ppt.temp = temp;
+        _this2.ks.putPths(signer.verfer.qb64, ppt);
+      });
+    } else {
+      throw new Error("invalid configuration, randy keys without encryption");
+    }
+    var pubSet = new PubSet();
+    pubSet.pubs = ps["new"].pubs;
+    this.ks.putPubs(riKey(pre, ridx), pubSet);
+    var nxtPubSet = new PubSet();
+    nxtPubSet.pubs = ps.nxt.pubs;
+    this.ks.putPubs(riKey(pre, ridx + 1), nxtPubSet);
+    return [verfers, digers];
+  };
+  _proto4.move = function move(old, gnu) {
+    if (old == gnu) {
+      return;
+    }
+    if (this.ks.getPres(old) == undefined) {
+      throw new Error("Nonexistent old pre=" + old + ", nothing to assign.");
+    }
+    if (this.ks.getPres(gnu) != undefined) {
+      throw new Error("Preexistent new pre=" + gnu + " may not clobber.");
+    }
+    var oldprm = this.ks.getPrms(old);
+    if (oldprm == undefined) {
+      throw new Error("Nonexistent old prm for pre=" + old + ", nothing to move.");
+    }
+    if (this.ks.getPrms(gnu) != undefined) {
+      throw new Error("Preexistent new prm for pre=" + gnu + " may not clobber.");
+    }
+    var oldsit = this.ks.getSits(old);
+    if (oldsit == undefined) {
+      throw new Error("Nonexistent old sit for pre=" + old + ", nothing to move.");
+    }
+    if (this.ks.getSits(gnu) != undefined) {
+      throw new Error("Preexistent new sit for pre=" + gnu + " may not clobber.");
+    }
+    if (!this.ks.putPrms(gnu, oldprm)) {
+      throw new Error("Failed moving prm from old pre=" + old + " to new pre=" + gnu + ".");
+    } else {
+      this.ks.remPrms(old);
+    }
+    if (!this.ks.putSits(gnu, oldsit)) {
+      throw new Error("Failed moving sit from old pre=" + old + " to new pre=" + gnu + ".");
+    } else {
+      this.ks.remSits(old);
+    }
+    var i = 0;
+    while (true) {
+      var pl = this.ks.getPubs(riKey(old, i));
+      if (pl == undefined) {
+        break;
+      }
+      if (!this.ks.putPubs(riKey(gnu, i), pl)) {
+        throw new Error("Failed moving pubs at pre=" + old + " ri=" + i + " to new pre=" + gnu);
+      }
+      i = i + 1;
+    }
+    if (!this.ks.pinPres(old, b(gnu))) {
+      throw new Error("Failed assiging new pre=" + gnu + " to old pre=" + old + ".");
+    }
+    if (!this.ks.putPres(gnu, b(gnu))) {
+      throw new Error("Failed assiging new pre=" + gnu + ".");
+    }
+  };
+  _proto4.rotate = function rotate(_ref3) {
+    var _this3 = this;
+    var pre = _ref3.pre,
+      _ref3$ncodes = _ref3.ncodes,
+      ncodes = _ref3$ncodes === void 0 ? undefined : _ref3$ncodes,
+      _ref3$ncount = _ref3.ncount,
+      ncount = _ref3$ncount === void 0 ? 1 : _ref3$ncount,
+      _ref3$ncode = _ref3.ncode,
+      ncode = _ref3$ncode === void 0 ? MtrDex.Ed25519_Seed : _ref3$ncode,
+      _ref3$dcode = _ref3.dcode,
+      dcode = _ref3$dcode === void 0 ? MtrDex.Blake3_256 : _ref3$dcode,
+      _ref3$transferable = _ref3.transferable,
+      transferable = _ref3$transferable === void 0 ? true : _ref3$transferable,
+      _ref3$temp = _ref3.temp,
+      temp = _ref3$temp === void 0 ? false : _ref3$temp,
+      _ref3$erase = _ref3.erase,
+      erase = _ref3$erase === void 0 ? true : _ref3$erase;
+    var pp = this.ks.getPrms(pre);
+    if (pp == undefined) {
+      throw new Error("Attempt to rotate nonexistent pre=" + pre + ".");
+    }
+    var ps = this.ks.getSits(pre);
+    if (ps == undefined) {
+      throw new Error("Attempt to rotate nonexistent pre=" + pre + ".");
+    }
+    if (ps.nxt.pubs == undefined || ps.nxt.pubs.length == 0) {
+      throw new Error("Attempt to rotate nontransferable pre=" + pre + ".");
+    }
+    var old = ps.old;
+    ps.old = ps["new"];
+    ps["new"] = ps.nxt;
+    if (this.aeid != undefined && this.decrypter == undefined) {
+      throw new Error("Unauthorized decryption attempt.  Aeid but no decrypter.");
+    }
+    var verfers = new Array();
+    ps["new"].pubs.forEach(function (pub) {
+      if (_this3.decrypter != undefined) {
+        var signer = _this3.ks.getPris(pub, _this3.decrypter);
+        if (signer == undefined) {
+          throw new Error("Missing prikey in db for pubkey=" + pub);
+        }
+        verfers.push(signer.verfer);
+      } else {
+        // Should we regenerate from salt here since this.decryptor is undefined
+        verfers.push(new Verfer({
+          qb64: pub
+        }));
+      }
+    });
+    var salt = pp.salt;
+    if (salt != undefined && salt != "") {
+      // If you provded a Salt for an AID but don't have encryption, pitch a fit
+      if (this.decrypter == undefined) {
+        throw new Error("Invalid configuration: AID salt with no encryption");
+      }
+      salt = this.decrypter.decrypt(b(salt)).qb64;
+    } else {
+      salt = this.salt;
+    }
+    var creator = new Creatory(pp.algo).make(salt, pp.tier, pp.stem);
+    if (ncodes == undefined) {
+      if (ncount < 0) {
+        throw new Error("Invalid count=" + ncount + " must be >= 0");
+      }
+      ncodes = new Array(ncount).fill(ncode);
+    }
+    var pidx = pp.pidx;
+    var ridx = ps["new"].ridx + 1;
+    var kidx = ps.nxt.kidx + ps["new"].pubs.length;
+    var keys = creator.create(ncodes, 0, "", transferable, pidx, ridx, kidx, temp);
+    var digers = Array.from(keys.signers, function (signer) {
+      return new Diger({
+        code: dcode
+      }, signer.verfer.qb64b);
+    });
+    var dt = new Date().toString();
+    ps.nxt = new PubLot();
+    ps.nxt.pubs = Array.from(keys.signers, function (signer) {
+      return signer.verfer.qb64;
+    });
+    ps.nxt.ridx = ridx;
+    ps.nxt.kidx = kidx;
+    ps.nxt.dt = dt;
+    if (!this.ks.pinSits(pre, ps)) {
+      throw new Error("Problem updating pubsit db for pre=" + pre + ".");
+    }
+    if (this.encrypter != undefined) {
+      // Only store encrypted keys if we have an encrypter, otherwise regenerate
+      keys.signers.forEach(function (signer) {
+        _this3.ks.putPris(signer.verfer.qb64, signer, _this3.encrypter);
+      });
+    } else if (this._encrypter == undefined && keys.paths != undefined) {
+      keys.paths.forEach(function (path, idx) {
+        var signer = keys.signers[idx];
+        var ppt = new PubPath();
+        ppt.path = path;
+        ppt.tier = pp.tier;
+        ppt.temp = temp;
+        _this3.ks.putPths(signer.verfer.qb64, ppt);
+      });
+    } else {
+      throw new Error("invalid configuration, randy keys without encryption");
+    }
+    var newPs = new PubSet();
+    newPs.pubs = ps.nxt.pubs;
+    this.ks.putPubs(riKey(pre, ps.nxt.ridx), newPs);
+    if (erase) {
+      old.pubs.forEach(function (pub) {
+        _this3.ks.remPris(pub);
+      });
+    }
+    return [verfers, digers];
+  };
+  _proto4.sign = function sign(_ref4) {
+    var _this4 = this;
+    var ser = _ref4.ser,
+      _ref4$pubs = _ref4.pubs,
+      pubs = _ref4$pubs === void 0 ? undefined : _ref4$pubs,
+      _ref4$verfers = _ref4.verfers,
+      verfers = _ref4$verfers === void 0 ? undefined : _ref4$verfers,
+      _ref4$indexed = _ref4.indexed,
+      indexed = _ref4$indexed === void 0 ? true : _ref4$indexed,
+      _ref4$indices = _ref4.indices,
+      indices = _ref4$indices === void 0 ? undefined : _ref4$indices,
+      _ref4$ondices = _ref4.ondices,
+      ondices = _ref4$ondices === void 0 ? undefined : _ref4$ondices;
+    var signers = new Array();
+    if (pubs == undefined && verfers == undefined) {
+      throw new Error("pubs or verfers required");
+    }
+    if (pubs != undefined) {
+      if (this.aeid != undefined && this.decrypter == undefined) {
+        throw new Error("Unauthorized decryption attempt.  Aeid but no decrypter.");
+      }
+      pubs.forEach(function (pub) {
+        //If no decrypter then get SaltyState and regenerate prikey
+        if (_this4.decrypter != undefined) {
+          var signer = _this4.ks.getPris(pub, _this4.decrypter);
+          if (signer == undefined) {
+            throw new Error("Missing prikey in db for pubkey=" + pub);
+          }
+          signers.push(signer);
+        } else {
+          var verfer = new Verfer({
+            qb64: pub
+          });
+          var ppt = _this4.ks.getPths(pub);
+          if (ppt == undefined) {
+            throw new Error("Missing prikey in db for pubkey=" + pub);
+          }
+          var salter = new Salter({
+            qb64: _this4.salt
+          });
+          signers.push(salter.signer(ppt.code, verfer.transferable, ppt.path, ppt.tier, ppt.temp));
+        }
+      });
+    } else {
+      verfers.forEach(function (verfer) {
+        if (_this4.decrypter != undefined) {
+          var signer = _this4.ks.getPris(verfer.qb64, _this4.decrypter);
+          if (signer == undefined) {
+            throw new Error("Missing prikey in db for pubkey=" + verfer.qb64);
+          }
+          signers.push(signer);
+        } else {
+          var ppt = _this4.ks.getPths(verfer.qb64);
+          if (ppt == undefined) {
+            throw new Error("Missing prikey in db for pubkey=" + verfer.qb64);
+          }
+          var salter = new Salter({
+            qb64: _this4.salt
+          });
+          signers.push(salter.signer(ppt.code, verfer.transferable, ppt.path, ppt.tier, ppt.temp));
+        }
+      });
+    }
+    if (indices != undefined && indices.length != signers.length) {
+      throw new Error("Mismatch indices length=" + indices.length + " and resultant signers length=" + signers.length);
+    }
+    if (ondices != undefined && ondices.length != signers.length) {
+      throw new Error("Mismatch ondices length=" + ondices.length + " and resultant signers length=" + signers.length);
+    }
+    if (indexed) {
+      var sigers = new Array();
+      signers.forEach(function (signer, idx) {
+        var i;
+        if (indices != undefined) {
+          i = indices[idx];
+          if (i < 0) {
+            throw new Error("Invalid signing index = " + i + ", not whole number.");
+          }
+        } else {
+          i = idx;
+        }
+        var o;
+        if (ondices != undefined) {
+          o = ondices[idx];
+          if (o <= 0) {
+            throw new Error("Invalid other signing index = {o}, not None or not whole number.");
+          }
+        } else {
+          o = i;
+        }
+        var only = o == undefined;
+        sigers.push(signer.sign(ser, i, only, o));
+      });
+      return sigers;
+    } else {
+      var cigars = new Array();
+      signers.forEach(function (signer) {
+        cigars.push(signer.sign(ser));
+      });
+      return cigars;
+    }
+  };
+  _createClass(Manager, [{
+    key: "ks",
+    get: function get() {
+      return this._ks;
+    }
+  }, {
+    key: "encrypter",
+    get: function get() {
+      return this._encrypter;
+    }
+  }, {
+    key: "decrypter",
+    get: function get() {
+      return this._decrypter;
+    }
+  }, {
+    key: "seed",
+    get: function get() {
+      return this._seed;
+    }
+  }, {
+    key: "aeid",
+    get: function get() {
+      return this.ks.getGbls('aeid');
+    }
+  }, {
+    key: "pidx",
+    get: function get() {
+      var pidx = this.ks.getGbls('pidx');
+      if (pidx != undefined) {
+        return parseInt(pidx, 16);
+      }
+      return undefined;
+    },
+    set: function set(pidx) {
+      this.ks.pinGbls('pidx', pidx.toString(16));
+    }
+  }, {
+    key: "salt",
+    get: function get() {
+      if (this._decrypter == undefined) {
+        return this._salt;
+      } else {
+        var salt = this.ks.getGbls('salt');
+        return this._decrypter.decrypt(b(salt)).qb64;
+      }
+    },
+    set: function set(salt) {
+      if (this._encrypter == undefined) {
+        this._salt = salt;
+      } else {
+        salt = this._encrypter.encrypt(b(salt)).qb64;
+        this.ks.pinGbls('salt', salt);
+      }
+    }
+  }, {
+    key: "tier",
+    get: function get() {
+      return this.ks.getGbls('tier');
+    },
+    set: function set(tier) {
+      this.ks.pinGbls('tier', tier);
+    }
+  }, {
+    key: "algo",
+    get: function get() {
+      var a = this.ks.getGbls('algo');
+      var ta = a;
+      return Algos[ta];
+    },
+    set: function set(algo) {
+      this.ks.pinGbls('algo', algo);
+    }
+  }]);
+  return Manager;
+}();
+function riKey(pre, ridx) {
+  return pre + "." + ridx.toString(16).padStart(32, '0');
+}
+/*
+     In memory test implementation of Keeper key store
+*/
+var Keeper = /*#__PURE__*/function () {
+  function Keeper() {
+    this._gbls = new Map();
+    this._pris = new Map();
+    this._pths = new Map();
+    this._pres = new Map();
+    this._prms = new Map();
+    this._sits = new Map();
+    this._pubs = new Map();
+  }
+  var _proto5 = Keeper.prototype;
+  _proto5.getGbls = function getGbls(key) {
+    return this._gbls.get(key);
+  };
+  _proto5.pinGbls = function pinGbls(key, val) {
+    this._gbls.set(key, val);
+  };
+  _proto5.prmsElements = function prmsElements() {
+    var out = new Array();
+    this._prms.forEach(function (value, key) {
+      out.push([key, value]);
+    });
+    return out;
+  };
+  _proto5.getPrms = function getPrms(keys) {
+    return this._prms.get(keys);
+  };
+  _proto5.pinPrms = function pinPrms(keys, data) {
+    this._prms.set(keys, data);
+  };
+  _proto5.putPrms = function putPrms(keys, data) {
+    if (this._prms.has(keys)) {
+      return false;
+    }
+    this._prms.set(keys, data);
+    return true;
+  };
+  _proto5.remPrms = function remPrms(keys) {
+    return this._prms["delete"](keys);
+  };
+  _proto5.prisElements = function prisElements(decrypter) {
+    var out = new Array();
+    this._pris.forEach(function (val, pubKey) {
+      var verfer = new Verfer({
+        qb64: pubKey
+      });
+      var signer = decrypter.decrypt(val, null, verfer.transferable);
+      out.push([pubKey, signer]);
+    });
+    return out;
+  };
+  _proto5.pinPris = function pinPris(pubKey, signer, encrypter) {
+    var cipher = encrypter.encrypt(null, signer);
+    this._pris.set(pubKey, cipher.qb64b);
+  };
+  _proto5.putPris = function putPris(pubKey, signer, encrypter) {
+    if (this._pris.has(pubKey)) {
+      return false;
+    }
+    var cipher = encrypter.encrypt(null, signer);
+    this._pris.set(pubKey, cipher.qb64b);
+    return true;
+  };
+  _proto5.getPris = function getPris(pubKey, decrypter) {
+    var val = this._pris.get(pubKey);
+    if (val == undefined) {
+      return undefined;
+    }
+    var verfer = new Verfer({
+      qb64: pubKey
+    });
+    return decrypter.decrypt(val, null, verfer.transferable);
+  };
+  _proto5.pinPths = function pinPths(pubKey, val) {
+    this._pths.set(pubKey, val);
+    return true;
+  };
+  _proto5.putPths = function putPths(pubKey, val) {
+    if (this._pths.has(pubKey)) {
+      return false;
+    }
+    this._pths.set(pubKey, val);
+    return true;
+  };
+  _proto5.getPths = function getPths(pubKey) {
+    return this._pths.get(pubKey);
+  };
+  _proto5.remPris = function remPris(pubKey) {
+    this._pris["delete"](pubKey);
+  };
+  _proto5.getPres = function getPres(pre) {
+    return this._pres.get(pre);
+  };
+  _proto5.pinPres = function pinPres(pre, val) {
+    this._pres.set(pre, val);
+    return true;
+  };
+  _proto5.putPres = function putPres(pre, val) {
+    if (this._pres.has(pre)) {
+      return false;
+    }
+    this._pres.set(pre, val);
+    return true;
+  };
+  _proto5.getSits = function getSits(keys) {
+    return this._sits.get(keys);
+  };
+  _proto5.putSits = function putSits(pre, val) {
+    if (this._sits.has(pre)) {
+      return false;
+    }
+    this._sits.set(pre, val);
+    return true;
+  };
+  _proto5.pinSits = function pinSits(pre, val) {
+    this._sits.set(pre, val);
+    return true;
+  };
+  _proto5.remSits = function remSits(keys) {
+    return this._sits["delete"](keys);
+  };
+  _proto5.getPubs = function getPubs(keys) {
+    return this._pubs.get(keys);
+  };
+  _proto5.putPubs = function putPubs(keys, data) {
+    if (this._pubs.has(keys)) {
+      return false;
+    }
+    this._pubs.set(keys, data);
+    return true;
+  };
+  return Keeper;
+}();
+
+var Tholder = /*#__PURE__*/function () {
+  function Tholder(sith) {
+    this._weighted = false;
+    this._thold = 0;
+    this._size = 0;
+    this._sith = "";
+    this._limen = new Array();
+    this.processSith(sith);
+  }
+  var _proto = Tholder.prototype;
+  _proto.processSith = function processSith(sith) {
+    if (typeof sith == "string") {
+      this._sith = sith;
+      this._thold = parseInt(sith);
+    } else if (typeof sith == "number") {
+      this._thold = sith;
+      this._size = this._thold;
+    } else {
+      this._limen = sith;
+      this._size = this._limen.length;
+    }
+  };
+  _createClass(Tholder, [{
+    key: "num",
+    get: function get() {
+      return this._weighted ? undefined : this._thold;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this._size;
+    }
+  }, {
+    key: "thold",
+    get: function get() {
+      return this._thold;
+    }
+  }, {
+    key: "weighted",
+    get: function get() {
+      return this._weighted;
+    }
+  }, {
+    key: "sith",
+    get: function get() {
+      if (this.weighted) {
+        if (this._sith == "") {
+          return "" + this._limen;
+        }
+        return this._sith;
+      } else {
+        return this.thold.toString(16);
+      }
+    }
+  }]);
+  return Tholder;
+}();
+
+var PNumber = /*#__PURE__*/function () {
+  function PNumber(num, numh) {
+    this._num = 0;
+    // TODO: Implelment logic
+    if (typeof num == "number") {
+      this._num = num;
+    } else if (numh != undefined) {
+      this._num = parseInt(numh, 16);
+    }
+  }
+  _createClass(PNumber, [{
+    key: "num",
+    get: function get() {
+      return this._num;
+    }
+  }, {
+    key: "numh",
+    get: function get() {
+      return this._num.toString(16);
+    }
+  }]);
+  return PNumber;
+}();
+
+var Serder = /*#__PURE__*/function () {
+  function Serder(ked, kind, code) {
+    if (kind === void 0) {
+      kind = Serials.JSON;
+    }
+    if (code === void 0) {
+      code = MtrDex.Blake3_256;
+    }
+    this._raw = "";
+    this._ked = {};
+    this._ident = Ident.KERI;
+    this._size = 0;
+    this._version = Versionage;
+    this._code = code;
+    this._kind = kind;
+    this.ked = ked;
+  }
+  var _proto = Serder.prototype;
+  _proto._exhale = function _exhale(ked, kind) {
+    return sizeify(ked, kind);
+  };
+  _proto.pretty = function pretty() {
+    return JSON.stringify(this._ked, undefined, 2);
+  };
+  _createClass(Serder, [{
+    key: "ked",
+    get: function get() {
+      return this._ked;
+    },
+    set: function set(ked) {
+      var _this$_exhale = this._exhale(ked, this._kind),
+        raw = _this$_exhale[0],
+        ident = _this$_exhale[1],
+        kind = _this$_exhale[2],
+        kd = _this$_exhale[3],
+        version = _this$_exhale[4];
+      var size = raw.length;
+      this._raw = raw;
+      this._ident = ident;
+      this._ked = kd;
+      this._kind = kind;
+      this._size = size;
+      this._version = version;
+    }
+  }, {
+    key: "code",
+    get: function get() {
+      return this._code;
+    }
+  }, {
+    key: "raw",
+    get: function get() {
+      return this._raw;
+    }
+  }, {
+    key: "kind",
+    get: function get() {
+      return this._kind;
+    }
+  }, {
+    key: "ident",
+    get: function get() {
+      return this._ident;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return this._size;
+    }
+  }, {
+    key: "version",
+    get: function get() {
+      return this._version;
+    }
+  }]);
+  return Serder;
+}();
+function dumps(ked, kind) {
+  if (kind == Serials.JSON) {
+    return JSON.stringify(ked);
+  } else {
+    throw new Error("unsupported event encoding");
+  }
+}
+function sizeify(ked, kind) {
+  if (!("v" in ked)) {
+    throw new Error("Missing or empty version string");
+  }
+  var ident = Ident.KERI;
+  var _deversify = deversify(ked["v"]),
+    knd = _deversify[0],
+    version = _deversify[1];
+  if (version != Versionage) {
+    throw new Error("unsupported version " + version.toString());
+  }
+  if (kind == undefined) {
+    kind = knd;
+  }
+  var raw = dumps(ked, kind);
+  var size = raw.length;
+  ked['v'] = versify(ident, version, kind, size);
+  raw = dumps(ked, kind);
+  return [raw, ident, kind, ked, version];
+}
+
+var Dummy = "#";
+var Prefixer = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Prefixer, _Matter);
+  function Prefixer(_ref, ked) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      qb64b = _ref.qb64b,
+      qb64 = _ref.qb64,
+      qb2 = _ref.qb2;
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64b: qb64b,
+        qb64: qb64,
+        qb2: qb2
+      }) || this;
+    } catch (e) {
+      if (e instanceof EmptyMaterialError) {
+        if (ked == undefined || code == undefined && !("i" in ked)) {
+          throw e;
+        }
+        if (code == undefined) {
+          _this = _Matter.call(this, {
+            qb64: ked['i'],
+            code: code
+          }) || this;
+          code = _this.code;
+        }
+        var _derive;
+        if (code == MtrDex.Ed25519N) {
+          _derive = Prefixer._derive_ed25519N;
+        } else if (code == MtrDex.Ed25519) {
+          _derive = Prefixer._derive_ed25519;
+        } else if (code == MtrDex.Blake3_256) {
+          _derive = Prefixer._derive_blake3_256;
+        } else {
+          throw new Error("Unsupported code = " + code + " for prefixer.");
+        }
+        var _derive2 = _derive(ked);
+        raw = _derive2[0];
+        code = _derive2[1];
+        _this = _Matter.call(this, {
+          raw: raw,
+          code: code
+        }) || this;
+        _this._derive = _derive;
+      } else {
+        throw e;
+      }
+    }
+    if (_this.code == MtrDex.Ed25519N) {
+      _this._verify = _this._verify_ed25519N;
+    } else if (_this.code == MtrDex.Ed25519) {
+      _this._verify = _this._verify_ed25519;
+    } else if (_this.code == MtrDex.Blake3_256) {
+      _this._verify = _this._verify_blake3_256;
+    } else {
+      throw new Error("Unsupported code = " + code + " for prefixer.");
+    }
+    return _assertThisInitialized(_this);
+  }
+  var _proto = Prefixer.prototype;
+  _proto.derive = function derive(ked) {
+    if (ked["i"] != Ilks.icp) {
+      throw new Error("Non-incepting ilk " + ked['i'] + " for prefix derivation");
+    }
+    return this._derive(ked);
+  };
+  _proto.verify = function verify(ked, prefixed) {
+    if (prefixed === void 0) {
+      prefixed = false;
+    }
+    if (ked["i"] != Ilks.icp) {
+      throw new Error("Non-incepting ilk " + ked['i'] + " for prefix derivation");
+    }
+    return this._verify(ked, this.qb64, prefixed);
+  };
+  Prefixer._derive_ed25519N = function _derive_ed25519N(ked) {
+    var verfer;
+    var keys = ked["k"];
+    if (keys.length != 1) {
+      throw new Error("Basic derivation needs at most 1 key got " + keys.length + " keys instead");
+    }
+    try {
+      verfer = new Verfer({
+        qb64: keys[0]
+      });
+    } catch (e) {
+      throw new Error("Error extracting public key = " + e);
+    }
+    if (!(verfer.code in [MtrDex.Ed25519N])) {
+      throw new Error("Mismatch derivation code = " + verfer.code);
+    }
+    var next = 'n' in ked ? ked['n'] : [];
+    if (verfer.code == MtrDex.Ed25519N && next.length > 0) {
+      throw new Error("Non-empty nxt = " + next + " for non-transferable code = " + verfer.code);
+    }
+    var backers = 'b' in ked ? ked['b'] : [];
+    if (verfer.code == MtrDex.Ed25519N && backers.length > 0) {
+      throw new Error("Non-empty b =" + backers + " for non-transferable code = " + verfer.code);
+    }
+    var anchor = 'a' in ked ? ked['a'] : [];
+    if (verfer.code == MtrDex.Ed25519N && anchor.length > 0) {
+      throw new Error("Non-empty a = " + verfer.code + " for non-transferable code = " + verfer.code);
+    }
+    return [verfer.raw, verfer.code];
+  };
+  Prefixer._derive_ed25519 = function _derive_ed25519(ked) {
+    var verfer;
+    var keys = ked["k"];
+    if (keys.length != 1) {
+      throw new Error("Basic derivation needs at most 1 key got " + keys.length + " keys instead");
+    }
+    try {
+      verfer = new Verfer({
+        qb64: keys[0]
+      });
+    } catch (e) {
+      throw new Error("Error extracting public key = " + e);
+    }
+    if (verfer.code in [MtrDex.Ed25519]) {
+      throw new Error("Mismatch derivation code = " + verfer.code);
+    }
+    return [verfer.raw, verfer.code];
+  };
+  Prefixer._derive_blake3_256 = function _derive_blake3_256(ked) {
+    var kd = ked;
+    var ilk = ked["t"];
+    if (ilk != Ilks.icp) {
+      throw new Error("Invalid ilk = " + ilk + " to derive pre.");
+    }
+    kd["i"] = "".padStart(Matter.Sizes.get(MtrDex.Blake3_256).fs, Dummy);
+    kd["d"] = ked["i"];
+    var _sizeify = sizeify(ked),
+      raw = _sizeify[0];
+    var hasher = blake3.createHash();
+    var dig = hasher.update(raw).digest('');
+    return [dig, MtrDex.Blake3_256];
+  };
+  _proto._verify_ed25519N = function _verify_ed25519N(ked, pre, prefixed) {
+    if (prefixed === void 0) {
+      prefixed = false;
+    }
+    try {
+      var keys = ked["k"];
+      if (keys.length != 1) {
+        return false;
+      }
+      if (keys[0] != pre) {
+        return false;
+      }
+      if (prefixed && ked["i"] != pre) {
+        return false;
+      }
+      var next = 'n' in ked ? ked['n'] : [];
+      if (next.length > 0) {
+        // must be empty
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+  _proto._verify_ed25519 = function _verify_ed25519(ked, pre, prefixed) {
+    if (prefixed === void 0) {
+      prefixed = false;
+    }
+    try {
+      var keys = ked["k"];
+      if (keys.length != 1) {
+        return false;
+      }
+      if (keys[0] != pre) {
+        return false;
+      }
+      if (prefixed && ked["i"] != pre) {
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+  _proto._verify_blake3_256 = function _verify_blake3_256(ked, pre, prefixed) {
+    if (prefixed === void 0) {
+      prefixed = false;
+    }
+    try {
+      var _Prefixer$_derive_bla = Prefixer._derive_blake3_256(ked),
+        raw = _Prefixer$_derive_bla[0];
+      var crymat = new Matter({
+        raw: raw,
+        code: MtrDex.Blake3_256
+      });
+      if (crymat.qb64 != pre) {
+        return false;
+      }
+      if (prefixed && ked["i"] != pre) {
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+  return Prefixer;
+}(Matter);
+
+var Dummy$1 = "#";
+var Ids;
+(function (Ids) {
+  Ids["d"] = "d";
+})(Ids || (Ids = {}));
+var Digestage = function Digestage(klas, size, length) {
+  this.klas = undefined;
+  this.size = 0;
+  this.length = 0;
+  this.klas = klas;
+  this.size = size;
+  this.length = length;
 };
+var Saider = /*#__PURE__*/function (_Matter) {
+  _inheritsLoose(Saider, _Matter);
+  function Saider(_ref, sad, kind, label) {
+    var _this;
+    var raw = _ref.raw,
+      code = _ref.code,
+      qb64b = _ref.qb64b,
+      qb64 = _ref.qb64,
+      qb2 = _ref.qb2;
+    if (label === void 0) {
+      label = Ids.d;
+    }
+    try {
+      _this = _Matter.call(this, {
+        raw: raw,
+        code: code,
+        qb64b: qb64b,
+        qb64: qb64,
+        qb2: qb2
+      }) || this;
+    } catch (e) {
+      if (e instanceof EmptyMaterialError) {
+        if (sad == undefined || !(label in sad)) {
+          throw e;
+        }
+        if (code == undefined) {
+          if (sad[label] != "") {
+            _this = _Matter.call(this, {
+              qb64: sad[label],
+              code: code
+            }) || this;
+            code = _this.code;
+          } else {
+            code = MtrDex.Blake3_256;
+          }
+        }
+        if (!DigiDex.has(code)) {
+          throw new Error("Unsupported digest code = " + code);
+        }
+        var _Saider$_derive = Saider._derive(_extends({}, sad), code, kind, label);
+        raw = _Saider$_derive[0];
+        _this = _Matter.call(this, {
+          raw: raw,
+          code: code
+        }) || this;
+      } else {
+        throw e;
+      }
+    }
+    if (!_this.digestive) {
+      throw new Error("Unsupported digest code = " + _this.code + ".");
+    }
+    return _assertThisInitialized(_this);
+  }
+  Saider._derive_blake3_256 = function _derive_blake3_256(ser, _digest_size, _length) {
+    var hasher = blake3.createHash();
+    return hasher.update(ser).digest('');
+  };
+  Saider._derive = function _derive(sad, code, kind, label) {
+    if (!DigiDex.has(code) || !Saider.Digests.has(code)) {
+      throw new Error("Unsupported digest code = " + code + ".");
+    }
+    sad = _extends({}, sad);
+    sad[label] = "".padStart(Matter.Sizes.get(code).fs, Dummy$1);
+    if ('v' in sad) {
+      var _sizeify = sizeify(sad, kind);
+      kind = _sizeify[2];
+      sad = _sizeify[3];
+    }
+    var ser = _extends({}, sad);
+    var digestage = Saider.Digests.get(code);
+    var cpa = Saider._serialze(ser, kind);
+    var args = [];
+    if (digestage.size != undefined) {
+      args.push(digestage.size);
+    }
+    if (digestage.length != undefined) {
+      args.push(digestage.length);
+    }
+    return [digestage.klas.apply(digestage, [cpa].concat(args)), sad];
+  };
+  var _proto = Saider.prototype;
+  _proto.derive = function derive(sad, code, kind, label) {
+    code = code != undefined ? code : this.code;
+    return Saider._derive(sad, code, kind, label);
+  };
+  _proto.verify = function verify(sad, prefixed, versioned, kind, label) {
+    if (prefixed === void 0) {
+      prefixed = false;
+    }
+    if (versioned === void 0) {
+      versioned = false;
+    }
+    if (label === void 0) {
+      label = Ids.d;
+    }
+    try {
+      var _Saider$_derive2 = Saider._derive(sad, this.code, kind, label),
+        raw = _Saider$_derive2[0],
+        dsad = _Saider$_derive2[1];
+      var saider = new Saider({
+        raw: raw,
+        code: this.code
+      });
+      if (this.qb64 != saider.qb64) {
+        return false;
+      }
+      if ("v" in sad && versioned) {
+        if (sad['v'] != dsad["v"]) {
+          return false;
+        }
+      }
+      if (prefixed && sad[label] != this.qb64) {
+        return false;
+      }
+    } catch (e) {
+      return false;
+    }
+    return true;
+  };
+  Saider._serialze = function _serialze(sad, kind) {
+    var knd = Serials.JSON;
+    if ('v' in sad) {
+      var _deversify = deversify(sad['v']);
+      knd = _deversify[0];
+    }
+    if (kind == undefined) {
+      kind = knd;
+    }
+    return dumps(sad, kind);
+  };
+  Saider.saidify = function saidify(sad, code, kind, label) {
+    if (code === void 0) {
+      code = MtrDex.Blake3_256;
+    }
+    if (kind === void 0) {
+      kind = Serials.JSON;
+    }
+    if (label === void 0) {
+      label = Ids.d;
+    }
+    if (!(label in sad)) {
+      throw new Error("Missing id field labeled=" + label + " in sad.");
+    }
+    var raw;
+    var _Saider$_derive3 = Saider._derive(sad, code, kind, label);
+    raw = _Saider$_derive3[0];
+    sad = _Saider$_derive3[1];
+    var saider = new Saider({
+      raw: raw,
+      code: code
+    }, undefined, kind, label);
+    sad[label] = saider.qb64;
+    return [saider, sad];
+  };
+  return Saider;
+}(Matter);
+Saider.Digests = /*#__PURE__*/new Map([[MtrDex.Blake3_256, /*#__PURE__*/new Digestage(Saider._derive_blake3_256, undefined, undefined)]]);
+
+function ample(n, f, weak) {
+  if (weak === void 0) {
+    weak = true;
+  }
+  n = Math.max(0, n); // no negatives
+  var f1;
+  if (f == undefined) {
+    f1 = Math.max(1, Math.floor(Math.max(0, n - 1) / 3)); // least floor f subject to n >= 3*f+1
+    var f2 = Math.max(1, Math.ceil(Math.max(0, n - 1) / 3)); // most Math.ceil f subject to n >= 3*f+1
+    if (weak) {
+      // try both fs to see which one has lowest m
+      return Math.min(n, Math.ceil((n + f1 + 1) / 2), Math.ceil((n + f2 + 1) / 2));
+    } else {
+      return Math.min(n, Math.max(0, n - f1, Math.ceil((n + f1 + 1) / 2)));
+    }
+  } else {
+    f = Math.max(0, f);
+    var m1 = Math.ceil((n + f + 1) / 2);
+    var m2 = Math.max(0, n - f);
+    if (m2 < m1 && n > 0) {
+      throw new Error("Invalid f=" + f + " is too big for n=" + n + ".");
+    }
+    if (weak) {
+      return Math.min(n, m1, m2);
+    } else {
+      return Math.min(n, Math.max(m1, m2));
+    }
+  }
+}
+function incept(_ref) {
+  var keys = _ref.keys,
+    isith = _ref.isith,
+    ndigs = _ref.ndigs,
+    nsith = _ref.nsith,
+    toad = _ref.toad,
+    wits = _ref.wits,
+    cnfg = _ref.cnfg,
+    data = _ref.data,
+    _ref$version = _ref.version,
+    version = _ref$version === void 0 ? Versionage : _ref$version,
+    _ref$kind = _ref.kind,
+    kind = _ref$kind === void 0 ? Serials.JSON : _ref$kind,
+    code = _ref.code,
+    _ref$intive = _ref.intive,
+    intive = _ref$intive === void 0 ? false : _ref$intive,
+    delpre = _ref.delpre;
+  var vs = versify(Ident.KERI, version, kind, 0);
+  var ilk = delpre == undefined ? Ilks.icp : Ilks.dip;
+  var sner = new PNumber(0);
+  if (isith == undefined) {
+    isith = Math.max(1, Math.ceil(keys.length / 2));
+  }
+  var tholder = new Tholder(isith);
+  if (tholder.num != undefined && tholder.num < 1) {
+    throw new Error("Invalid sith = " + tholder.num + " less than 1.");
+  }
+  if (tholder.size > keys.length) {
+    throw new Error("Invalid sith = " + tholder.num + " for keys " + keys);
+  }
+  if (ndigs == undefined) {
+    ndigs = new Array();
+  }
+  if (nsith == undefined) {
+    nsith = Math.max(0, Math.ceil(ndigs.length / 2));
+  }
+  var ntholder = new Tholder(nsith);
+  if (ntholder.num != undefined && ntholder.num < 0) {
+    throw new Error("Invalid nsith = " + ntholder.num + " less than 0.");
+  }
+  if (ntholder.size > keys.length) {
+    throw new Error("Invalid nsith = " + ntholder.num + " for keys " + ndigs);
+  }
+  wits = wits == undefined ? [] : wits;
+  if (new Set(wits).size != wits.length) {
+    throw new Error("Invalid wits = " + wits + ", has duplicates.");
+  }
+  if (toad == undefined) {
+    if (wits.length == 0) {
+      toad = 0;
+    } else {
+      toad = ample(wits.length);
+    }
+  }
+  var toader = new PNumber(toad);
+  if (wits.length > 0) {
+    if (toader.num < 1 || toader.num > wits.length) {
+      throw new Error("Invalid toad = " + toader.num + " for wits = " + wits);
+    }
+  } else {
+    if (toader.num != 0) {
+      throw new Error("Invalid toad = " + toader.num + " for wits = " + wits);
+    }
+  }
+  cnfg = cnfg == undefined ? new Array() : cnfg;
+  data = data == undefined ? new Array() : data;
+  var ked = {
+    v: vs,
+    t: ilk,
+    d: "",
+    i: "",
+    s: sner.numh,
+    kt: intive && tholder.num != undefined ? tholder.num : tholder.sith,
+    k: keys,
+    nt: intive && tholder.num != undefined ? ntholder.num : ntholder.sith,
+    n: ndigs,
+    bt: intive ? toader.num : toader.numh,
+    b: wits,
+    c: cnfg,
+    a: data
+  };
+  if (delpre != undefined) {
+    ked["di"] = delpre;
+    if (code == undefined) {
+      code = MtrDex.Blake3_256;
+    }
+  }
+  var prefixer;
+  if (delpre == undefined && code == undefined && keys.length == 1) {
+    prefixer = new Prefixer({
+      qb64: keys[0]
+    });
+    if (prefixer.digestive) {
+      throw new Error("Invalid code, digestive=" + prefixer.code + ", must be derived from ked.");
+    }
+  } else {
+    prefixer = new Prefixer({
+      code: code
+    }, ked);
+    if (delpre != undefined) {
+      if (!prefixer.digestive) {
+        throw new Error("Invalid derivation code = " + prefixer.code + " for delegation. Must be digestive");
+      }
+    }
+  }
+  ked["i"] = prefixer.qb64;
+  if (prefixer.digestive) {
+    ked["d"] = prefixer.qb64;
+  } else {
+    var _Saider$saidify = Saider.saidify(ked);
+    ked = _Saider$saidify[1];
+  }
+  return new Serder(ked);
+}
+
+var TraitCodex = function TraitCodex() {
+  this.EstOnly = 'EO'; // Only allow establishment events
+  this.DoNotDelegate = 'DND'; // Dot not allow delegated identifiers
+};
+
+var TraitDex = /*#__PURE__*/new TraitCodex();
+var Hab = /*#__PURE__*/function () {
+  function Hab(name, icp) {
+    this.name = name;
+    this.serder = icp;
+  }
+  _createClass(Hab, [{
+    key: "pre",
+    get: function get() {
+      return this.serder.ked["i"];
+    }
+  }]);
+  return Hab;
+}();
+var Habery = /*#__PURE__*/function () {
+  function Habery(_ref) {
+    var name = _ref.name,
+      passcode = _ref.passcode,
+      seed = _ref.seed,
+      aeid = _ref.aeid,
+      pidx = _ref.pidx,
+      salt = _ref.salt;
+    this._habs = new Map();
+    this._name = name;
+    if (passcode != undefined && seed == undefined) {
+      if (passcode.length < 21) {
+        throw new Error("Bran (passcode seed material) too short.");
+      }
+      var bran = MtrDex.Salt_128 + 'A' + passcode.substring(0, 21); // qb64 salt for seed
+      var signer = new Salter({
+        qb64: bran
+      }).signer(MtrDex.Ed25519_Seed, false);
+      seed = signer.qb64;
+      if (aeid == undefined) {
+        aeid = signer.verfer.qb64; // lest it remove encryption
+      }
+    }
+
+    var algo;
+    if (salt != undefined) {
+      algo = Algos.salty;
+      salt = new Salter({
+        qb64: salt
+      }).qb64;
+    } else {
+      algo = Algos.randy;
+    }
+    this._mgr = new Manager({
+      seed: seed,
+      aeid: aeid,
+      pidx: pidx,
+      algo: algo,
+      salt: salt
+    });
+  }
+  var _proto = Habery.prototype;
+  _proto.habByName = function habByName(name) {
+    return this._habs.get(name);
+  };
+  _proto.makeHab = function makeHab(name, _ref2) {
+    var _ref2$code = _ref2.code,
+      code = _ref2$code === void 0 ? MtrDex.Blake3_256 : _ref2$code,
+      _ref2$transferable = _ref2.transferable,
+      transferable = _ref2$transferable === void 0 ? true : _ref2$transferable,
+      _ref2$isith = _ref2.isith,
+      isith = _ref2$isith === void 0 ? undefined : _ref2$isith,
+      _ref2$icount = _ref2.icount,
+      icount = _ref2$icount === void 0 ? 1 : _ref2$icount,
+      _ref2$nsith = _ref2.nsith,
+      nsith = _ref2$nsith === void 0 ? undefined : _ref2$nsith,
+      _ref2$ncount = _ref2.ncount,
+      ncount = _ref2$ncount === void 0 ? undefined : _ref2$ncount,
+      _ref2$toad = _ref2.toad,
+      toad = _ref2$toad === void 0 ? undefined : _ref2$toad,
+      _ref2$wits = _ref2.wits,
+      wits = _ref2$wits === void 0 ? undefined : _ref2$wits,
+      _ref2$delpre = _ref2.delpre,
+      delpre = _ref2$delpre === void 0 ? undefined : _ref2$delpre,
+      _ref2$estOnly = _ref2.estOnly,
+      estOnly = _ref2$estOnly === void 0 ? false : _ref2$estOnly,
+      _ref2$DnD = _ref2.DnD,
+      DnD = _ref2$DnD === void 0 ? false : _ref2$DnD,
+      _ref2$data = _ref2.data,
+      data = _ref2$data === void 0 ? undefined : _ref2$data;
+    if (nsith == undefined) {
+      nsith = isith;
+    }
+    if (ncount == undefined) {
+      ncount = icount;
+    }
+    if (!transferable) {
+      ncount = 0;
+      nsith = "0";
+      code = MtrDex.Ed25519N;
+    }
+    var _this$_mgr$incept = this._mgr.incept({
+        icount: icount,
+        ncount: ncount,
+        stem: this.name,
+        transferable: transferable,
+        temp: false
+      }),
+      verfers = _this$_mgr$incept[0],
+      digers = _this$_mgr$incept[1];
+    icount = verfers.length;
+    ncount = digers != undefined ? digers.length : 0;
+    if (isith == undefined) {
+      isith = "" + Math.max(1, Math.ceil(icount / 2)).toString(16);
+    }
+    if (nsith == undefined) {
+      nsith = "" + Math.max(1, Math.ceil(ncount / 2)).toString(16);
+    }
+    var cnfg = new Array();
+    if (estOnly) {
+      cnfg.push(TraitDex.EstOnly);
+    }
+    if (DnD) {
+      cnfg.push(TraitDex.DoNotDelegate);
+    }
+    var keys = Array.from(verfers, function (verfer) {
+      return verfer.qb64;
+    });
+    var ndigs = Array.from(digers, function (diger) {
+      return diger.qb64;
+    });
+    var icp = incept({
+      keys: keys,
+      isith: isith,
+      ndigs: ndigs,
+      nsith: nsith,
+      toad: toad,
+      wits: wits,
+      cnfg: cnfg,
+      data: data,
+      code: code,
+      delpre: delpre
+    });
+    var hab = new Hab(name, icp);
+    this._habs.set(name, hab);
+    return hab;
+  };
+  _createClass(Habery, [{
+    key: "mgr",
+    get: function get() {
+      return this._mgr;
+    }
+  }, {
+    key: "habs",
+    get: function get() {
+      return Array.from(this._habs.values());
+    }
+  }, {
+    key: "name",
+    get: function get() {
+      return this._name;
+    }
+  }]);
+  return Habery;
+}();
 
-exports.sum = sum;
+exports.Codex = Codex;
+exports.DigiCodex = DigiCodex;
+exports.DigiDex = DigiDex;
+exports.Hab = Hab;
+exports.Habery = Habery;
+exports.Matter = Matter;
+exports.MatterCodex = MatterCodex;
+exports.MtrDex = MtrDex;
+exports.NonTransCodex = NonTransCodex;
+exports.NonTransDex = NonTransDex;
+exports.Salter = Salter;
+exports.Sizage = Sizage;
+exports.TraitCodex = TraitCodex;
+exports.TraitDex = TraitDex;
 //# sourceMappingURL=signify-ts.cjs.development.js.map