@leofcoin/chain 1.5.44 → 1.5.46

package/exports/browser/chain.js

@@ -1388,764 +1388,781 @@ function requireIterator () {
 	return iterator;
 }
 
-var yallist = Yallist$1;
+var yallist;
+var hasRequiredYallist;
 
-Yallist$1.Node = Node;
-Yallist$1.create = Yallist$1;
+function requireYallist () {
+	if (hasRequiredYallist) return yallist;
+	hasRequiredYallist = 1;
+	yallist = Yallist;
 
-function Yallist$1 (list) {
-  var self = this;
-  if (!(self instanceof Yallist$1)) {
-    self = new Yallist$1();
-  }
+	Yallist.Node = Node;
+	Yallist.create = Yallist;
 
-  self.tail = null;
-  self.head = null;
-  self.length = 0;
+	function Yallist (list) {
+	  var self = this;
+	  if (!(self instanceof Yallist)) {
+	    self = new Yallist();
+	  }
 
-  if (list && typeof list.forEach === 'function') {
-    list.forEach(function (item) {
-      self.push(item);
-    });
-  } else if (arguments.length > 0) {
-    for (var i = 0, l = arguments.length; i < l; i++) {
-      self.push(arguments[i]);
-    }
-  }
+	  self.tail = null;
+	  self.head = null;
+	  self.length = 0;
 
-  return self
-}
+	  if (list && typeof list.forEach === 'function') {
+	    list.forEach(function (item) {
+	      self.push(item);
+	    });
+	  } else if (arguments.length > 0) {
+	    for (var i = 0, l = arguments.length; i < l; i++) {
+	      self.push(arguments[i]);
+	    }
+	  }
 
-Yallist$1.prototype.removeNode = function (node) {
-  if (node.list !== this) {
-    throw new Error('removing node which does not belong to this list')
-  }
+	  return self
+	}
 
-  var next = node.next;
-  var prev = node.prev;
+	Yallist.prototype.removeNode = function (node) {
+	  if (node.list !== this) {
+	    throw new Error('removing node which does not belong to this list')
+	  }
 
-  if (next) {
-    next.prev = prev;
-  }
+	  var next = node.next;
+	  var prev = node.prev;
 
-  if (prev) {
-    prev.next = next;
-  }
+	  if (next) {
+	    next.prev = prev;
+	  }
 
-  if (node === this.head) {
-    this.head = next;
-  }
-  if (node === this.tail) {
-    this.tail = prev;
-  }
+	  if (prev) {
+	    prev.next = next;
+	  }
 
-  node.list.length--;
-  node.next = null;
-  node.prev = null;
-  node.list = null;
+	  if (node === this.head) {
+	    this.head = next;
+	  }
+	  if (node === this.tail) {
+	    this.tail = prev;
+	  }
 
-  return next
-};
+	  node.list.length--;
+	  node.next = null;
+	  node.prev = null;
+	  node.list = null;
 
-Yallist$1.prototype.unshiftNode = function (node) {
-  if (node === this.head) {
-    return
-  }
+	  return next
+	};
 
-  if (node.list) {
-    node.list.removeNode(node);
-  }
+	Yallist.prototype.unshiftNode = function (node) {
+	  if (node === this.head) {
+	    return
+	  }
 
-  var head = this.head;
-  node.list = this;
-  node.next = head;
-  if (head) {
-    head.prev = node;
-  }
+	  if (node.list) {
+	    node.list.removeNode(node);
+	  }
 
-  this.head = node;
-  if (!this.tail) {
-    this.tail = node;
-  }
-  this.length++;
-};
+	  var head = this.head;
+	  node.list = this;
+	  node.next = head;
+	  if (head) {
+	    head.prev = node;
+	  }
 
-Yallist$1.prototype.pushNode = function (node) {
-  if (node === this.tail) {
-    return
-  }
+	  this.head = node;
+	  if (!this.tail) {
+	    this.tail = node;
+	  }
+	  this.length++;
+	};
 
-  if (node.list) {
-    node.list.removeNode(node);
-  }
+	Yallist.prototype.pushNode = function (node) {
+	  if (node === this.tail) {
+	    return
+	  }
 
-  var tail = this.tail;
-  node.list = this;
-  node.prev = tail;
-  if (tail) {
-    tail.next = node;
-  }
+	  if (node.list) {
+	    node.list.removeNode(node);
+	  }
 
-  this.tail = node;
-  if (!this.head) {
-    this.head = node;
-  }
-  this.length++;
-};
+	  var tail = this.tail;
+	  node.list = this;
+	  node.prev = tail;
+	  if (tail) {
+	    tail.next = node;
+	  }
 
-Yallist$1.prototype.push = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    push(this, arguments[i]);
-  }
-  return this.length
-};
+	  this.tail = node;
+	  if (!this.head) {
+	    this.head = node;
+	  }
+	  this.length++;
+	};
 
-Yallist$1.prototype.unshift = function () {
-  for (var i = 0, l = arguments.length; i < l; i++) {
-    unshift(this, arguments[i]);
-  }
-  return this.length
-};
+	Yallist.prototype.push = function () {
+	  for (var i = 0, l = arguments.length; i < l; i++) {
+	    push(this, arguments[i]);
+	  }
+	  return this.length
+	};
 
-Yallist$1.prototype.pop = function () {
-  if (!this.tail) {
-    return undefined
-  }
+	Yallist.prototype.unshift = function () {
+	  for (var i = 0, l = arguments.length; i < l; i++) {
+	    unshift(this, arguments[i]);
+	  }
+	  return this.length
+	};
 
-  var res = this.tail.value;
-  this.tail = this.tail.prev;
-  if (this.tail) {
-    this.tail.next = null;
-  } else {
-    this.head = null;
-  }
-  this.length--;
-  return res
-};
+	Yallist.prototype.pop = function () {
+	  if (!this.tail) {
+	    return undefined
+	  }
 
-Yallist$1.prototype.shift = function () {
-  if (!this.head) {
-    return undefined
-  }
+	  var res = this.tail.value;
+	  this.tail = this.tail.prev;
+	  if (this.tail) {
+	    this.tail.next = null;
+	  } else {
+	    this.head = null;
+	  }
+	  this.length--;
+	  return res
+	};
 
-  var res = this.head.value;
-  this.head = this.head.next;
-  if (this.head) {
-    this.head.prev = null;
-  } else {
-    this.tail = null;
-  }
-  this.length--;
-  return res
-};
+	Yallist.prototype.shift = function () {
+	  if (!this.head) {
+	    return undefined
+	  }
 
-Yallist$1.prototype.forEach = function (fn, thisp) {
-  thisp = thisp || this;
-  for (var walker = this.head, i = 0; walker !== null; i++) {
-    fn.call(thisp, walker.value, i, this);
-    walker = walker.next;
-  }
-};
+	  var res = this.head.value;
+	  this.head = this.head.next;
+	  if (this.head) {
+	    this.head.prev = null;
+	  } else {
+	    this.tail = null;
+	  }
+	  this.length--;
+	  return res
+	};
 
-Yallist$1.prototype.forEachReverse = function (fn, thisp) {
-  thisp = thisp || this;
-  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
-    fn.call(thisp, walker.value, i, this);
-    walker = walker.prev;
-  }
-};
+	Yallist.prototype.forEach = function (fn, thisp) {
+	  thisp = thisp || this;
+	  for (var walker = this.head, i = 0; walker !== null; i++) {
+	    fn.call(thisp, walker.value, i, this);
+	    walker = walker.next;
+	  }
+	};
 
-Yallist$1.prototype.get = function (n) {
-  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.next;
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-};
+	Yallist.prototype.forEachReverse = function (fn, thisp) {
+	  thisp = thisp || this;
+	  for (var walker = this.tail, i = this.length - 1; walker !== null; i--) {
+	    fn.call(thisp, walker.value, i, this);
+	    walker = walker.prev;
+	  }
+	};
 
-Yallist$1.prototype.getReverse = function (n) {
-  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
-    // abort out of the list early if we hit a cycle
-    walker = walker.prev;
-  }
-  if (i === n && walker !== null) {
-    return walker.value
-  }
-};
+	Yallist.prototype.get = function (n) {
+	  for (var i = 0, walker = this.head; walker !== null && i < n; i++) {
+	    // abort out of the list early if we hit a cycle
+	    walker = walker.next;
+	  }
+	  if (i === n && walker !== null) {
+	    return walker.value
+	  }
+	};
 
-Yallist$1.prototype.map = function (fn, thisp) {
-  thisp = thisp || this;
-  var res = new Yallist$1();
-  for (var walker = this.head; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this));
-    walker = walker.next;
-  }
-  return res
-};
+	Yallist.prototype.getReverse = function (n) {
+	  for (var i = 0, walker = this.tail; walker !== null && i < n; i++) {
+	    // abort out of the list early if we hit a cycle
+	    walker = walker.prev;
+	  }
+	  if (i === n && walker !== null) {
+	    return walker.value
+	  }
+	};
 
-Yallist$1.prototype.mapReverse = function (fn, thisp) {
-  thisp = thisp || this;
-  var res = new Yallist$1();
-  for (var walker = this.tail; walker !== null;) {
-    res.push(fn.call(thisp, walker.value, this));
-    walker = walker.prev;
-  }
-  return res
-};
+	Yallist.prototype.map = function (fn, thisp) {
+	  thisp = thisp || this;
+	  var res = new Yallist();
+	  for (var walker = this.head; walker !== null;) {
+	    res.push(fn.call(thisp, walker.value, this));
+	    walker = walker.next;
+	  }
+	  return res
+	};
 
-Yallist$1.prototype.reduce = function (fn, initial) {
-  var acc;
-  var walker = this.head;
-  if (arguments.length > 1) {
-    acc = initial;
-  } else if (this.head) {
-    walker = this.head.next;
-    acc = this.head.value;
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
+	Yallist.prototype.mapReverse = function (fn, thisp) {
+	  thisp = thisp || this;
+	  var res = new Yallist();
+	  for (var walker = this.tail; walker !== null;) {
+	    res.push(fn.call(thisp, walker.value, this));
+	    walker = walker.prev;
+	  }
+	  return res
+	};
 
-  for (var i = 0; walker !== null; i++) {
-    acc = fn(acc, walker.value, i);
-    walker = walker.next;
-  }
+	Yallist.prototype.reduce = function (fn, initial) {
+	  var acc;
+	  var walker = this.head;
+	  if (arguments.length > 1) {
+	    acc = initial;
+	  } else if (this.head) {
+	    walker = this.head.next;
+	    acc = this.head.value;
+	  } else {
+	    throw new TypeError('Reduce of empty list with no initial value')
+	  }
 
-  return acc
-};
+	  for (var i = 0; walker !== null; i++) {
+	    acc = fn(acc, walker.value, i);
+	    walker = walker.next;
+	  }
 
-Yallist$1.prototype.reduceReverse = function (fn, initial) {
-  var acc;
-  var walker = this.tail;
-  if (arguments.length > 1) {
-    acc = initial;
-  } else if (this.tail) {
-    walker = this.tail.prev;
-    acc = this.tail.value;
-  } else {
-    throw new TypeError('Reduce of empty list with no initial value')
-  }
+	  return acc
+	};
 
-  for (var i = this.length - 1; walker !== null; i--) {
-    acc = fn(acc, walker.value, i);
-    walker = walker.prev;
-  }
+	Yallist.prototype.reduceReverse = function (fn, initial) {
+	  var acc;
+	  var walker = this.tail;
+	  if (arguments.length > 1) {
+	    acc = initial;
+	  } else if (this.tail) {
+	    walker = this.tail.prev;
+	    acc = this.tail.value;
+	  } else {
+	    throw new TypeError('Reduce of empty list with no initial value')
+	  }
 
-  return acc
-};
+	  for (var i = this.length - 1; walker !== null; i--) {
+	    acc = fn(acc, walker.value, i);
+	    walker = walker.prev;
+	  }
 
-Yallist$1.prototype.toArray = function () {
-  var arr = new Array(this.length);
-  for (var i = 0, walker = this.head; walker !== null; i++) {
-    arr[i] = walker.value;
-    walker = walker.next;
-  }
-  return arr
-};
+	  return acc
+	};
 
-Yallist$1.prototype.toArrayReverse = function () {
-  var arr = new Array(this.length);
-  for (var i = 0, walker = this.tail; walker !== null; i++) {
-    arr[i] = walker.value;
-    walker = walker.prev;
-  }
-  return arr
-};
+	Yallist.prototype.toArray = function () {
+	  var arr = new Array(this.length);
+	  for (var i = 0, walker = this.head; walker !== null; i++) {
+	    arr[i] = walker.value;
+	    walker = walker.next;
+	  }
+	  return arr
+	};
 
-Yallist$1.prototype.slice = function (from, to) {
-  to = to || this.length;
-  if (to < 0) {
-    to += this.length;
-  }
-  from = from || 0;
-  if (from < 0) {
-    from += this.length;
-  }
-  var ret = new Yallist$1();
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0;
-  }
-  if (to > this.length) {
-    to = this.length;
-  }
-  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
-    walker = walker.next;
-  }
-  for (; walker !== null && i < to; i++, walker = walker.next) {
-    ret.push(walker.value);
-  }
-  return ret
-};
+	Yallist.prototype.toArrayReverse = function () {
+	  var arr = new Array(this.length);
+	  for (var i = 0, walker = this.tail; walker !== null; i++) {
+	    arr[i] = walker.value;
+	    walker = walker.prev;
+	  }
+	  return arr
+	};
 
-Yallist$1.prototype.sliceReverse = function (from, to) {
-  to = to || this.length;
-  if (to < 0) {
-    to += this.length;
-  }
-  from = from || 0;
-  if (from < 0) {
-    from += this.length;
-  }
-  var ret = new Yallist$1();
-  if (to < from || to < 0) {
-    return ret
-  }
-  if (from < 0) {
-    from = 0;
-  }
-  if (to > this.length) {
-    to = this.length;
-  }
-  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
-    walker = walker.prev;
-  }
-  for (; walker !== null && i > from; i--, walker = walker.prev) {
-    ret.push(walker.value);
-  }
-  return ret
-};
+	Yallist.prototype.slice = function (from, to) {
+	  to = to || this.length;
+	  if (to < 0) {
+	    to += this.length;
+	  }
+	  from = from || 0;
+	  if (from < 0) {
+	    from += this.length;
+	  }
+	  var ret = new Yallist();
+	  if (to < from || to < 0) {
+	    return ret
+	  }
+	  if (from < 0) {
+	    from = 0;
+	  }
+	  if (to > this.length) {
+	    to = this.length;
+	  }
+	  for (var i = 0, walker = this.head; walker !== null && i < from; i++) {
+	    walker = walker.next;
+	  }
+	  for (; walker !== null && i < to; i++, walker = walker.next) {
+	    ret.push(walker.value);
+	  }
+	  return ret
+	};
 
-Yallist$1.prototype.splice = function (start, deleteCount, ...nodes) {
-  if (start > this.length) {
-    start = this.length - 1;
-  }
-  if (start < 0) {
-    start = this.length + start;
-  }
+	Yallist.prototype.sliceReverse = function (from, to) {
+	  to = to || this.length;
+	  if (to < 0) {
+	    to += this.length;
+	  }
+	  from = from || 0;
+	  if (from < 0) {
+	    from += this.length;
+	  }
+	  var ret = new Yallist();
+	  if (to < from || to < 0) {
+	    return ret
+	  }
+	  if (from < 0) {
+	    from = 0;
+	  }
+	  if (to > this.length) {
+	    to = this.length;
+	  }
+	  for (var i = this.length, walker = this.tail; walker !== null && i > to; i--) {
+	    walker = walker.prev;
+	  }
+	  for (; walker !== null && i > from; i--, walker = walker.prev) {
+	    ret.push(walker.value);
+	  }
+	  return ret
+	};
 
-  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
-    walker = walker.next;
-  }
+	Yallist.prototype.splice = function (start, deleteCount, ...nodes) {
+	  if (start > this.length) {
+	    start = this.length - 1;
+	  }
+	  if (start < 0) {
+	    start = this.length + start;
+	  }
 
-  var ret = [];
-  for (var i = 0; walker && i < deleteCount; i++) {
-    ret.push(walker.value);
-    walker = this.removeNode(walker);
-  }
-  if (walker === null) {
-    walker = this.tail;
-  }
+	  for (var i = 0, walker = this.head; walker !== null && i < start; i++) {
+	    walker = walker.next;
+	  }
 
-  if (walker !== this.head && walker !== this.tail) {
-    walker = walker.prev;
-  }
+	  var ret = [];
+	  for (var i = 0; walker && i < deleteCount; i++) {
+	    ret.push(walker.value);
+	    walker = this.removeNode(walker);
+	  }
+	  if (walker === null) {
+	    walker = this.tail;
+	  }
 
-  for (var i = 0; i < nodes.length; i++) {
-    walker = insert(this, walker, nodes[i]);
-  }
-  return ret;
-};
+	  if (walker !== this.head && walker !== this.tail) {
+	    walker = walker.prev;
+	  }
 
-Yallist$1.prototype.reverse = function () {
-  var head = this.head;
-  var tail = this.tail;
-  for (var walker = head; walker !== null; walker = walker.prev) {
-    var p = walker.prev;
-    walker.prev = walker.next;
-    walker.next = p;
-  }
-  this.head = tail;
-  this.tail = head;
-  return this
-};
+	  for (var i = 0; i < nodes.length; i++) {
+	    walker = insert(this, walker, nodes[i]);
+	  }
+	  return ret;
+	};
 
-function insert (self, node, value) {
-  var inserted = node === self.head ?
-    new Node(value, null, node, self) :
-    new Node(value, node, node.next, self);
+	Yallist.prototype.reverse = function () {
+	  var head = this.head;
+	  var tail = this.tail;
+	  for (var walker = head; walker !== null; walker = walker.prev) {
+	    var p = walker.prev;
+	    walker.prev = walker.next;
+	    walker.next = p;
+	  }
+	  this.head = tail;
+	  this.tail = head;
+	  return this
+	};
 
-  if (inserted.next === null) {
-    self.tail = inserted;
-  }
-  if (inserted.prev === null) {
-    self.head = inserted;
-  }
+	function insert (self, node, value) {
+	  var inserted = node === self.head ?
+	    new Node(value, null, node, self) :
+	    new Node(value, node, node.next, self);
 
-  self.length++;
+	  if (inserted.next === null) {
+	    self.tail = inserted;
+	  }
+	  if (inserted.prev === null) {
+	    self.head = inserted;
+	  }
 
-  return inserted
-}
+	  self.length++;
 
-function push (self, item) {
-  self.tail = new Node(item, self.tail, null, self);
-  if (!self.head) {
-    self.head = self.tail;
-  }
-  self.length++;
-}
+	  return inserted
+	}
 
-function unshift (self, item) {
-  self.head = new Node(item, null, self.head, self);
-  if (!self.tail) {
-    self.tail = self.head;
-  }
-  self.length++;
-}
+	function push (self, item) {
+	  self.tail = new Node(item, self.tail, null, self);
+	  if (!self.head) {
+	    self.head = self.tail;
+	  }
+	  self.length++;
+	}
 
-function Node (value, prev, next, list) {
-  if (!(this instanceof Node)) {
-    return new Node(value, prev, next, list)
-  }
+	function unshift (self, item) {
+	  self.head = new Node(item, null, self.head, self);
+	  if (!self.tail) {
+	    self.tail = self.head;
+	  }
+	  self.length++;
+	}
 
-  this.list = list;
-  this.value = value;
+	function Node (value, prev, next, list) {
+	  if (!(this instanceof Node)) {
+	    return new Node(value, prev, next, list)
+	  }
 
-  if (prev) {
-    prev.next = this;
-    this.prev = prev;
-  } else {
-    this.prev = null;
-  }
+	  this.list = list;
+	  this.value = value;
 
-  if (next) {
-    next.prev = this;
-    this.next = next;
-  } else {
-    this.next = null;
-  }
+	  if (prev) {
+	    prev.next = this;
+	    this.prev = prev;
+	  } else {
+	    this.prev = null;
+	  }
+
+	  if (next) {
+	    next.prev = this;
+	    this.next = next;
+	  } else {
+	    this.next = null;
+	  }
+	}
+
+	try {
+	  // add if support for Symbol.iterator is present
+	  requireIterator()(Yallist);
+	} catch (er) {}
+	return yallist;
 }
 
-try {
-  // add if support for Symbol.iterator is present
-  requireIterator()(Yallist$1);
-} catch (er) {}
-
-// A linked list to keep track of recently-used-ness
-const Yallist = yallist;
-
-const MAX = Symbol('max');
-const LENGTH = Symbol('length');
-const LENGTH_CALCULATOR = Symbol('lengthCalculator');
-const ALLOW_STALE = Symbol('allowStale');
-const MAX_AGE = Symbol('maxAge');
-const DISPOSE = Symbol('dispose');
-const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
-const LRU_LIST = Symbol('lruList');
-const CACHE = Symbol('cache');
-const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
-
-const naiveLength = () => 1;
-
-// lruList is a yallist where the head is the youngest
-// item, and the tail is the oldest.  the list contains the Hit
-// objects as the entries.
-// Each Hit object has a reference to its Yallist.Node.  This
-// never changes.
-//
-// cache is a Map (or PseudoMap) that matches the keys to
-// the Yallist.Node object.
-class LRUCache {
-  constructor (options) {
-    if (typeof options === 'number')
-      options = { max: options };
-
-    if (!options)
-      options = {};
-
-    if (options.max && (typeof options.max !== 'number' || options.max < 0))
-      throw new TypeError('max must be a non-negative number')
-    // Kind of weird to have a default max of Infinity, but oh well.
-    this[MAX] = options.max || Infinity;
-
-    const lc = options.length || naiveLength;
-    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
-    this[ALLOW_STALE] = options.stale || false;
-    if (options.maxAge && typeof options.maxAge !== 'number')
-      throw new TypeError('maxAge must be a number')
-    this[MAX_AGE] = options.maxAge || 0;
-    this[DISPOSE] = options.dispose;
-    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
-    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
-    this.reset();
-  }
+var lruCache;
+var hasRequiredLruCache;
+
+function requireLruCache () {
+	if (hasRequiredLruCache) return lruCache;
+	hasRequiredLruCache = 1;
+
+	// A linked list to keep track of recently-used-ness
+	const Yallist = requireYallist();
+
+	const MAX = Symbol('max');
+	const LENGTH = Symbol('length');
+	const LENGTH_CALCULATOR = Symbol('lengthCalculator');
+	const ALLOW_STALE = Symbol('allowStale');
+	const MAX_AGE = Symbol('maxAge');
+	const DISPOSE = Symbol('dispose');
+	const NO_DISPOSE_ON_SET = Symbol('noDisposeOnSet');
+	const LRU_LIST = Symbol('lruList');
+	const CACHE = Symbol('cache');
+	const UPDATE_AGE_ON_GET = Symbol('updateAgeOnGet');
+
+	const naiveLength = () => 1;
+
+	// lruList is a yallist where the head is the youngest
+	// item, and the tail is the oldest.  the list contains the Hit
+	// objects as the entries.
+	// Each Hit object has a reference to its Yallist.Node.  This
+	// never changes.
+	//
+	// cache is a Map (or PseudoMap) that matches the keys to
+	// the Yallist.Node object.
+	class LRUCache {
+	  constructor (options) {
+	    if (typeof options === 'number')
+	      options = { max: options };
+
+	    if (!options)
+	      options = {};
+
+	    if (options.max && (typeof options.max !== 'number' || options.max < 0))
+	      throw new TypeError('max must be a non-negative number')
+	    // Kind of weird to have a default max of Infinity, but oh well.
+	    this[MAX] = options.max || Infinity;
+
+	    const lc = options.length || naiveLength;
+	    this[LENGTH_CALCULATOR] = (typeof lc !== 'function') ? naiveLength : lc;
+	    this[ALLOW_STALE] = options.stale || false;
+	    if (options.maxAge && typeof options.maxAge !== 'number')
+	      throw new TypeError('maxAge must be a number')
+	    this[MAX_AGE] = options.maxAge || 0;
+	    this[DISPOSE] = options.dispose;
+	    this[NO_DISPOSE_ON_SET] = options.noDisposeOnSet || false;
+	    this[UPDATE_AGE_ON_GET] = options.updateAgeOnGet || false;
+	    this.reset();
+	  }
 
-  // resize the cache when the max changes.
-  set max (mL) {
-    if (typeof mL !== 'number' || mL < 0)
-      throw new TypeError('max must be a non-negative number')
+	  // resize the cache when the max changes.
+	  set max (mL) {
+	    if (typeof mL !== 'number' || mL < 0)
+	      throw new TypeError('max must be a non-negative number')
 
-    this[MAX] = mL || Infinity;
-    trim(this);
-  }
-  get max () {
-    return this[MAX]
-  }
+	    this[MAX] = mL || Infinity;
+	    trim(this);
+	  }
+	  get max () {
+	    return this[MAX]
+	  }
 
-  set allowStale (allowStale) {
-    this[ALLOW_STALE] = !!allowStale;
-  }
-  get allowStale () {
-    return this[ALLOW_STALE]
-  }
+	  set allowStale (allowStale) {
+	    this[ALLOW_STALE] = !!allowStale;
+	  }
+	  get allowStale () {
+	    return this[ALLOW_STALE]
+	  }
 
-  set maxAge (mA) {
-    if (typeof mA !== 'number')
-      throw new TypeError('maxAge must be a non-negative number')
+	  set maxAge (mA) {
+	    if (typeof mA !== 'number')
+	      throw new TypeError('maxAge must be a non-negative number')
 
-    this[MAX_AGE] = mA;
-    trim(this);
-  }
-  get maxAge () {
-    return this[MAX_AGE]
-  }
+	    this[MAX_AGE] = mA;
+	    trim(this);
+	  }
+	  get maxAge () {
+	    return this[MAX_AGE]
+	  }
 
-  // resize the cache when the lengthCalculator changes.
-  set lengthCalculator (lC) {
-    if (typeof lC !== 'function')
-      lC = naiveLength;
-
-    if (lC !== this[LENGTH_CALCULATOR]) {
-      this[LENGTH_CALCULATOR] = lC;
-      this[LENGTH] = 0;
-      this[LRU_LIST].forEach(hit => {
-        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
-        this[LENGTH] += hit.length;
-      });
-    }
-    trim(this);
-  }
-  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
+	  // resize the cache when the lengthCalculator changes.
+	  set lengthCalculator (lC) {
+	    if (typeof lC !== 'function')
+	      lC = naiveLength;
+
+	    if (lC !== this[LENGTH_CALCULATOR]) {
+	      this[LENGTH_CALCULATOR] = lC;
+	      this[LENGTH] = 0;
+	      this[LRU_LIST].forEach(hit => {
+	        hit.length = this[LENGTH_CALCULATOR](hit.value, hit.key);
+	        this[LENGTH] += hit.length;
+	      });
+	    }
+	    trim(this);
+	  }
+	  get lengthCalculator () { return this[LENGTH_CALCULATOR] }
 
-  get length () { return this[LENGTH] }
-  get itemCount () { return this[LRU_LIST].length }
+	  get length () { return this[LENGTH] }
+	  get itemCount () { return this[LRU_LIST].length }
 
-  rforEach (fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this[LRU_LIST].tail; walker !== null;) {
-      const prev = walker.prev;
-      forEachStep(this, fn, walker, thisp);
-      walker = prev;
-    }
-  }
+	  rforEach (fn, thisp) {
+	    thisp = thisp || this;
+	    for (let walker = this[LRU_LIST].tail; walker !== null;) {
+	      const prev = walker.prev;
+	      forEachStep(this, fn, walker, thisp);
+	      walker = prev;
+	    }
+	  }
 
-  forEach (fn, thisp) {
-    thisp = thisp || this;
-    for (let walker = this[LRU_LIST].head; walker !== null;) {
-      const next = walker.next;
-      forEachStep(this, fn, walker, thisp);
-      walker = next;
-    }
-  }
+	  forEach (fn, thisp) {
+	    thisp = thisp || this;
+	    for (let walker = this[LRU_LIST].head; walker !== null;) {
+	      const next = walker.next;
+	      forEachStep(this, fn, walker, thisp);
+	      walker = next;
+	    }
+	  }
 
-  keys () {
-    return this[LRU_LIST].toArray().map(k => k.key)
-  }
+	  keys () {
+	    return this[LRU_LIST].toArray().map(k => k.key)
+	  }
 
-  values () {
-    return this[LRU_LIST].toArray().map(k => k.value)
-  }
+	  values () {
+	    return this[LRU_LIST].toArray().map(k => k.value)
+	  }
 
-  reset () {
-    if (this[DISPOSE] &&
-        this[LRU_LIST] &&
-        this[LRU_LIST].length) {
-      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
-    }
+	  reset () {
+	    if (this[DISPOSE] &&
+	        this[LRU_LIST] &&
+	        this[LRU_LIST].length) {
+	      this[LRU_LIST].forEach(hit => this[DISPOSE](hit.key, hit.value));
+	    }
 
-    this[CACHE] = new Map(); // hash of items by key
-    this[LRU_LIST] = new Yallist(); // list of items in order of use recency
-    this[LENGTH] = 0; // length of items in the list
-  }
+	    this[CACHE] = new Map(); // hash of items by key
+	    this[LRU_LIST] = new Yallist(); // list of items in order of use recency
+	    this[LENGTH] = 0; // length of items in the list
+	  }
 
-  dump () {
-    return this[LRU_LIST].map(hit =>
-      isStale(this, hit) ? false : {
-        k: hit.key,
-        v: hit.value,
-        e: hit.now + (hit.maxAge || 0)
-      }).toArray().filter(h => h)
-  }
+	  dump () {
+	    return this[LRU_LIST].map(hit =>
+	      isStale(this, hit) ? false : {
+	        k: hit.key,
+	        v: hit.value,
+	        e: hit.now + (hit.maxAge || 0)
+	      }).toArray().filter(h => h)
+	  }
 
-  dumpLru () {
-    return this[LRU_LIST]
-  }
+	  dumpLru () {
+	    return this[LRU_LIST]
+	  }
 
-  set (key, value, maxAge) {
-    maxAge = maxAge || this[MAX_AGE];
+	  set (key, value, maxAge) {
+	    maxAge = maxAge || this[MAX_AGE];
 
-    if (maxAge && typeof maxAge !== 'number')
-      throw new TypeError('maxAge must be a number')
+	    if (maxAge && typeof maxAge !== 'number')
+	      throw new TypeError('maxAge must be a number')
 
-    const now = maxAge ? Date.now() : 0;
-    const len = this[LENGTH_CALCULATOR](value, key);
+	    const now = maxAge ? Date.now() : 0;
+	    const len = this[LENGTH_CALCULATOR](value, key);
 
-    if (this[CACHE].has(key)) {
-      if (len > this[MAX]) {
-        del(this, this[CACHE].get(key));
-        return false
-      }
+	    if (this[CACHE].has(key)) {
+	      if (len > this[MAX]) {
+	        del(this, this[CACHE].get(key));
+	        return false
+	      }
 
-      const node = this[CACHE].get(key);
-      const item = node.value;
+	      const node = this[CACHE].get(key);
+	      const item = node.value;
 
-      // dispose of the old one before overwriting
-      // split out into 2 ifs for better coverage tracking
-      if (this[DISPOSE]) {
-        if (!this[NO_DISPOSE_ON_SET])
-          this[DISPOSE](key, item.value);
-      }
+	      // dispose of the old one before overwriting
+	      // split out into 2 ifs for better coverage tracking
+	      if (this[DISPOSE]) {
+	        if (!this[NO_DISPOSE_ON_SET])
+	          this[DISPOSE](key, item.value);
+	      }
 
-      item.now = now;
-      item.maxAge = maxAge;
-      item.value = value;
-      this[LENGTH] += len - item.length;
-      item.length = len;
-      this.get(key);
-      trim(this);
-      return true
-    }
+	      item.now = now;
+	      item.maxAge = maxAge;
+	      item.value = value;
+	      this[LENGTH] += len - item.length;
+	      item.length = len;
+	      this.get(key);
+	      trim(this);
+	      return true
+	    }
 
-    const hit = new Entry(key, value, len, now, maxAge);
+	    const hit = new Entry(key, value, len, now, maxAge);
 
-    // oversized objects fall out of cache automatically.
-    if (hit.length > this[MAX]) {
-      if (this[DISPOSE])
-        this[DISPOSE](key, value);
+	    // oversized objects fall out of cache automatically.
+	    if (hit.length > this[MAX]) {
+	      if (this[DISPOSE])
+	        this[DISPOSE](key, value);
 
-      return false
-    }
+	      return false
+	    }
 
-    this[LENGTH] += hit.length;
-    this[LRU_LIST].unshift(hit);
-    this[CACHE].set(key, this[LRU_LIST].head);
-    trim(this);
-    return true
-  }
+	    this[LENGTH] += hit.length;
+	    this[LRU_LIST].unshift(hit);
+	    this[CACHE].set(key, this[LRU_LIST].head);
+	    trim(this);
+	    return true
+	  }
 
-  has (key) {
-    if (!this[CACHE].has(key)) return false
-    const hit = this[CACHE].get(key).value;
-    return !isStale(this, hit)
-  }
+	  has (key) {
+	    if (!this[CACHE].has(key)) return false
+	    const hit = this[CACHE].get(key).value;
+	    return !isStale(this, hit)
+	  }
 
-  get (key) {
-    return get(this, key, true)
-  }
+	  get (key) {
+	    return get(this, key, true)
+	  }
 
-  peek (key) {
-    return get(this, key, false)
-  }
+	  peek (key) {
+	    return get(this, key, false)
+	  }
 
-  pop () {
-    const node = this[LRU_LIST].tail;
-    if (!node)
-      return null
+	  pop () {
+	    const node = this[LRU_LIST].tail;
+	    if (!node)
+	      return null
 
-    del(this, node);
-    return node.value
-  }
+	    del(this, node);
+	    return node.value
+	  }
 
-  del (key) {
-    del(this, this[CACHE].get(key));
-  }
+	  del (key) {
+	    del(this, this[CACHE].get(key));
+	  }
 
-  load (arr) {
-    // reset the cache
-    this.reset();
-
-    const now = Date.now();
-    // A previous serialized cache has the most recent items first
-    for (let l = arr.length - 1; l >= 0; l--) {
-      const hit = arr[l];
-      const expiresAt = hit.e || 0;
-      if (expiresAt === 0)
-        // the item was created without expiration in a non aged cache
-        this.set(hit.k, hit.v);
-      else {
-        const maxAge = expiresAt - now;
-        // dont add already expired items
-        if (maxAge > 0) {
-          this.set(hit.k, hit.v, maxAge);
-        }
-      }
-    }
-  }
+	  load (arr) {
+	    // reset the cache
+	    this.reset();
+
+	    const now = Date.now();
+	    // A previous serialized cache has the most recent items first
+	    for (let l = arr.length - 1; l >= 0; l--) {
+	      const hit = arr[l];
+	      const expiresAt = hit.e || 0;
+	      if (expiresAt === 0)
+	        // the item was created without expiration in a non aged cache
+	        this.set(hit.k, hit.v);
+	      else {
+	        const maxAge = expiresAt - now;
+	        // dont add already expired items
+	        if (maxAge > 0) {
+	          this.set(hit.k, hit.v, maxAge);
+	        }
+	      }
+	    }
+	  }
 
-  prune () {
-    this[CACHE].forEach((value, key) => get(this, key, false));
-  }
-}
+	  prune () {
+	    this[CACHE].forEach((value, key) => get(this, key, false));
+	  }
+	}
 
-const get = (self, key, doUse) => {
-  const node = self[CACHE].get(key);
-  if (node) {
-    const hit = node.value;
-    if (isStale(self, hit)) {
-      del(self, node);
-      if (!self[ALLOW_STALE])
-        return undefined
-    } else {
-      if (doUse) {
-        if (self[UPDATE_AGE_ON_GET])
-          node.value.now = Date.now();
-        self[LRU_LIST].unshiftNode(node);
-      }
-    }
-    return hit.value
-  }
-};
+	const get = (self, key, doUse) => {
+	  const node = self[CACHE].get(key);
+	  if (node) {
+	    const hit = node.value;
+	    if (isStale(self, hit)) {
+	      del(self, node);
+	      if (!self[ALLOW_STALE])
+	        return undefined
+	    } else {
+	      if (doUse) {
+	        if (self[UPDATE_AGE_ON_GET])
+	          node.value.now = Date.now();
+	        self[LRU_LIST].unshiftNode(node);
+	      }
+	    }
+	    return hit.value
+	  }
+	};
 
-const isStale = (self, hit) => {
-  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
-    return false
+	const isStale = (self, hit) => {
+	  if (!hit || (!hit.maxAge && !self[MAX_AGE]))
+	    return false
 
-  const diff = Date.now() - hit.now;
-  return hit.maxAge ? diff > hit.maxAge
-    : self[MAX_AGE] && (diff > self[MAX_AGE])
-};
+	  const diff = Date.now() - hit.now;
+	  return hit.maxAge ? diff > hit.maxAge
+	    : self[MAX_AGE] && (diff > self[MAX_AGE])
+	};
 
-const trim = self => {
-  if (self[LENGTH] > self[MAX]) {
-    for (let walker = self[LRU_LIST].tail;
-      self[LENGTH] > self[MAX] && walker !== null;) {
-      // We know that we're about to delete this one, and also
-      // what the next least recently used key will be, so just
-      // go ahead and set it now.
-      const prev = walker.prev;
-      del(self, walker);
-      walker = prev;
-    }
-  }
-};
+	const trim = self => {
+	  if (self[LENGTH] > self[MAX]) {
+	    for (let walker = self[LRU_LIST].tail;
+	      self[LENGTH] > self[MAX] && walker !== null;) {
+	      // We know that we're about to delete this one, and also
+	      // what the next least recently used key will be, so just
+	      // go ahead and set it now.
+	      const prev = walker.prev;
+	      del(self, walker);
+	      walker = prev;
+	    }
+	  }
+	};
 
-const del = (self, node) => {
-  if (node) {
-    const hit = node.value;
-    if (self[DISPOSE])
-      self[DISPOSE](hit.key, hit.value);
+	const del = (self, node) => {
+	  if (node) {
+	    const hit = node.value;
+	    if (self[DISPOSE])
+	      self[DISPOSE](hit.key, hit.value);
 
-    self[LENGTH] -= hit.length;
-    self[CACHE].delete(hit.key);
-    self[LRU_LIST].removeNode(node);
-  }
-};
+	    self[LENGTH] -= hit.length;
+	    self[CACHE].delete(hit.key);
+	    self[LRU_LIST].removeNode(node);
+	  }
+	};
 
-class Entry {
-  constructor (key, value, length, now, maxAge) {
-    this.key = key;
-    this.value = value;
-    this.length = length;
-    this.now = now;
-    this.maxAge = maxAge || 0;
-  }
-}
+	class Entry {
+	  constructor (key, value, length, now, maxAge) {
+	    this.key = key;
+	    this.value = value;
+	    this.length = length;
+	    this.now = now;
+	    this.maxAge = maxAge || 0;
+	  }
+	}
 
-const forEachStep = (self, fn, node, thisp) => {
-  let hit = node.value;
-  if (isStale(self, hit)) {
-    del(self, node);
-    if (!self[ALLOW_STALE])
-      hit = undefined;
-  }
-  if (hit)
-    fn.call(thisp, hit.value, hit.key, self);
-};
+	const forEachStep = (self, fn, node, thisp) => {
+	  let hit = node.value;
+	  if (isStale(self, hit)) {
+	    del(self, node);
+	    if (!self[ALLOW_STALE])
+	      hit = undefined;
+	  }
+	  if (hit)
+	    fn.call(thisp, hit.value, hit.key, self);
+	};
 
-var lruCache = LRUCache;
+	lruCache = LRUCache;
+	return lruCache;
+}
 
 var range;
 var hasRequiredRange;
@@ -2353,7 +2370,7 @@ function requireRange () {
 
 	range = Range;
 
-	const LRU = lruCache;
+	const LRU = requireLruCache();
 	const cache = new LRU({ max: 1000 });
 
 	const parseOptions = parseOptions_1;
@@ -3671,7 +3688,8 @@ class Transaction extends Protocol {
             await globalThis.transactionPoolStore.put(hash, message.encoded);
             // debug(`Added ${hash} to the transaction pool`)
             peernet.publish('add-transaction', message.encoded);
-            return { hash, data, fee: await calculateFee(message.decoded), wait, message };
+            const fee = await calculateFee(message.decoded);
+            return { hash, data, fee, wait, message };
         }
         catch (error) {
             console.log('remo');
@@ -3876,8 +3894,11 @@ class Machine {
                 break;
             }
             case 'debug': {
-                for (const message of data.messages)
-                    globalThis.debug(message);
+                globalThis.debug(data.message);
+                break;
+            }
+            case 'error': {
+                console.error(data.message);
                 break;
             }
             case 'machine-ready': {
@@ -4298,7 +4319,7 @@ class State extends Contract {
         try {
             await this.resolveBlocks();
             this.#machine = await new Machine(this.#blocks);
-            await this.#loadBlocks(this.#blocks);
+            // await this.#loadBlocks(this.#blocks)
         }
         catch (error) {
             if (isResolveError(error)) {
@@ -4737,6 +4758,13 @@ class Chain extends VersionControl {
         this.#participants = [];
         this.#participating = false;
         this.#jail = [];
+        this.#addTransaction = async (message) => {
+            const transaction = new TransactionMessage(message);
+            const hash = await transaction.hash();
+            if (await transactionPool.has(hash))
+                await transactionPool.delete(hash);
+            console.log(transaction);
+        };
         // @ts-ignore
         return this.#init();
     }
@@ -4840,9 +4868,7 @@ class Chain extends VersionControl {
         }, validatorInfo.timeout);
         this.#jail.push(validatorInfo.address);
     }
-    #addTransaction(message) {
-        console.log({ message });
-    }
+    #addTransaction;
     async #prepareRequest(request) {
         let node = await new globalThis.peernet.protos['peernet-request']({ request });
         return globalThis.peernet.prepareMessage(node);
@@ -4867,7 +4893,6 @@ class Chain extends VersionControl {
     }
     async #peerConnected(peerId) {
         const peer = peernet.getConnection(peerId);
-        console.log({ peer });
         // todo handle version changes
         // for now just do nothing if version doesn't match
         console.log(`${peer.version}, ${this.version}`);