@magda/arbitraries 3.0.1 → 3.0.2-alpha.1

package/dist/index.js

@@ -11,6 +11,9 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
     return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
 var __commonJS = (cb, mod) => function __require2() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
@@ -31,9 +34,22 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// ../cjs-shim.js
+import { createRequire } from "module";
+import path from "path";
+import url from "url";
+var init_cjs_shim = __esm({
+  "../cjs-shim.js"() {
+    globalThis.require = createRequire(import.meta.url);
+    globalThis.__filename = url.fileURLToPath(import.meta.url);
+    globalThis.__dirname = path.dirname(__filename);
+  }
+});
+
 // ../../node_modules/lodash/lodash.js
 var require_lodash = __commonJS({
   "../../node_modules/lodash/lodash.js"(exports, module) {
+    init_cjs_shim();
     (function() {
       var undefined2;
       var VERSION = "4.17.21";
@@ -1361,11 +1377,11 @@ var require_lodash = __commonJS({
             return isFunction(object[key]);
           });
         }
-        function baseGet(object, path) {
-          path = castPath(path, object);
-          var index = 0, length = path.length;
+        function baseGet(object, path2) {
+          path2 = castPath(path2, object);
+          var index = 0, length = path2.length;
           while (object != null && index < length) {
-            object = object[toKey(path[index++])];
+            object = object[toKey(path2[index++])];
           }
           return index && index == length ? object : undefined2;
         }
@@ -1429,10 +1445,10 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function baseInvoke(object, path, args) {
-          path = castPath(path, object);
-          object = parent(object, path);
-          var func = object == null ? object : object[toKey(last(path))];
+        function baseInvoke(object, path2, args) {
+          path2 = castPath(path2, object);
+          object = parent(object, path2);
+          var func = object == null ? object : object[toKey(last(path2))];
           return func == null ? undefined2 : apply(func, object, args);
         }
         function baseIsArguments(value) {
@@ -1588,13 +1604,13 @@ var require_lodash = __commonJS({
             return object === source || baseIsMatch(object, source, matchData);
           };
         }
-        function baseMatchesProperty(path, srcValue) {
-          if (isKey(path) && isStrictComparable(srcValue)) {
-            return matchesStrictComparable(toKey(path), srcValue);
+        function baseMatchesProperty(path2, srcValue) {
+          if (isKey(path2) && isStrictComparable(srcValue)) {
+            return matchesStrictComparable(toKey(path2), srcValue);
           }
           return function(object) {
-            var objValue = get(object, path);
-            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
+            var objValue = get(object, path2);
+            return objValue === undefined2 && objValue === srcValue ? hasIn(object, path2) : baseIsEqual(srcValue, objValue, COMPARE_PARTIAL_FLAG | COMPARE_UNORDERED_FLAG);
           };
         }
         function baseMerge(object, source, srcIndex, customizer, stack) {
@@ -1691,23 +1707,23 @@ var require_lodash = __commonJS({
           });
         }
         function basePick(object, paths) {
-          return basePickBy(object, paths, function(value, path) {
-            return hasIn(object, path);
+          return basePickBy(object, paths, function(value, path2) {
+            return hasIn(object, path2);
           });
         }
         function basePickBy(object, paths, predicate) {
           var index = -1, length = paths.length, result2 = {};
           while (++index < length) {
-            var path = paths[index], value = baseGet(object, path);
-            if (predicate(value, path)) {
-              baseSet(result2, castPath(path, object), value);
+            var path2 = paths[index], value = baseGet(object, path2);
+            if (predicate(value, path2)) {
+              baseSet(result2, castPath(path2, object), value);
             }
           }
           return result2;
         }
-        function basePropertyDeep(path) {
+        function basePropertyDeep(path2) {
           return function(object) {
-            return baseGet(object, path);
+            return baseGet(object, path2);
           };
         }
         function basePullAll(array, values2, iteratee2, comparator) {
@@ -1781,14 +1797,14 @@ var require_lodash = __commonJS({
           var array = values(collection);
           return shuffleSelf(array, baseClamp(n, 0, array.length));
         }
-        function baseSet(object, path, value, customizer) {
+        function baseSet(object, path2, value, customizer) {
           if (!isObject(object)) {
             return object;
           }
-          path = castPath(path, object);
-          var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+          path2 = castPath(path2, object);
+          var index = -1, length = path2.length, lastIndex = length - 1, nested = object;
           while (nested != null && ++index < length) {
-            var key = toKey(path[index]), newValue = value;
+            var key = toKey(path2[index]), newValue = value;
             if (key === "__proto__" || key === "constructor" || key === "prototype") {
               return object;
             }
@@ -1796,7 +1812,7 @@ var require_lodash = __commonJS({
               var objValue = nested[key];
               newValue = customizer ? customizer(objValue, key, nested) : undefined2;
               if (newValue === undefined2) {
-                newValue = isObject(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+                newValue = isObject(objValue) ? objValue : isIndex(path2[index + 1]) ? [] : {};
               }
             }
             assignValue(nested, key, newValue);
@@ -1962,13 +1978,13 @@ var require_lodash = __commonJS({
             }
           return result2;
         }
-        function baseUnset(object, path) {
-          path = castPath(path, object);
-          object = parent(object, path);
-          return object == null || delete object[toKey(last(path))];
+        function baseUnset(object, path2) {
+          path2 = castPath(path2, object);
+          object = parent(object, path2);
+          return object == null || delete object[toKey(last(path2))];
         }
-        function baseUpdate(object, path, updater, customizer) {
-          return baseSet(object, path, updater(baseGet(object, path)), customizer);
+        function baseUpdate(object, path2, updater, customizer) {
+          return baseSet(object, path2, updater(baseGet(object, path2)), customizer);
         }
         function baseWhile(array, predicate, isDrop, fromRight) {
           var length = array.length, index = fromRight ? length : -1;
@@ -2851,11 +2867,11 @@ var require_lodash = __commonJS({
           var match = source.match(reWrapDetails);
           return match ? match[1].split(reSplitDetails) : [];
         }
-        function hasPath(object, path, hasFunc) {
-          path = castPath(path, object);
-          var index = -1, length = path.length, result2 = false;
+        function hasPath(object, path2, hasFunc) {
+          path2 = castPath(path2, object);
+          var index = -1, length = path2.length, result2 = false;
           while (++index < length) {
-            var key = toKey(path[index]);
+            var key = toKey(path2[index]);
             if (!(result2 = object != null && hasFunc(object, key))) {
               break;
             }
@@ -3057,8 +3073,8 @@ var require_lodash = __commonJS({
             return apply(func, this, otherArgs);
           };
         }
-        function parent(object, path) {
-          return path.length < 2 ? object : baseGet(object, baseSlice(path, 0, -1));
+        function parent(object, path2) {
+          return path2.length < 2 ? object : baseGet(object, baseSlice(path2, 0, -1));
         }
         function reorder(array, indexes) {
           var arrLength = array.length, length = nativeMin(indexes.length, arrLength), oldArray = copyArray(array);
@@ -3693,10 +3709,10 @@ var require_lodash = __commonJS({
           }
           return isString(collection) ? fromIndex <= length && collection.indexOf(value, fromIndex) > -1 : !!length && baseIndexOf(collection, value, fromIndex) > -1;
         }
-        var invokeMap = baseRest(function(collection, path, args) {
-          var index = -1, isFunc = typeof path == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
+        var invokeMap = baseRest(function(collection, path2, args) {
+          var index = -1, isFunc = typeof path2 == "function", result2 = isArrayLike(collection) ? Array2(collection.length) : [];
           baseEach(collection, function(value) {
-            result2[++index] = isFunc ? apply(path, value, args) : baseInvoke(value, path, args);
+            result2[++index] = isFunc ? apply(path2, value, args) : baseInvoke(value, path2, args);
           });
           return result2;
         });
@@ -4348,15 +4364,15 @@ var require_lodash = __commonJS({
         function functionsIn(object) {
           return object == null ? [] : baseFunctions(object, keysIn(object));
         }
-        function get(object, path, defaultValue) {
-          var result2 = object == null ? undefined2 : baseGet(object, path);
+        function get(object, path2, defaultValue) {
+          var result2 = object == null ? undefined2 : baseGet(object, path2);
           return result2 === undefined2 ? defaultValue : result2;
         }
-        function has(object, path) {
-          return object != null && hasPath(object, path, baseHas);
+        function has(object, path2) {
+          return object != null && hasPath(object, path2, baseHas);
         }
-        function hasIn(object, path) {
-          return object != null && hasPath(object, path, baseHasIn);
+        function hasIn(object, path2) {
+          return object != null && hasPath(object, path2, baseHasIn);
         }
         var invert = createInverter(function(result2, value, key) {
           if (value != null && typeof value.toString != "function") {
@@ -4409,10 +4425,10 @@ var require_lodash = __commonJS({
             return result2;
           }
           var isDeep = false;
-          paths = arrayMap(paths, function(path) {
-            path = castPath(path, object);
-            isDeep || (isDeep = path.length > 1);
-            return path;
+          paths = arrayMap(paths, function(path2) {
+            path2 = castPath(path2, object);
+            isDeep || (isDeep = path2.length > 1);
+            return path2;
           });
           copyObject(object, getAllKeysIn(object), result2);
           if (isDeep) {
@@ -4438,19 +4454,19 @@ var require_lodash = __commonJS({
             return [prop];
           });
           predicate = getIteratee(predicate);
-          return basePickBy(object, props, function(value, path) {
-            return predicate(value, path[0]);
+          return basePickBy(object, props, function(value, path2) {
+            return predicate(value, path2[0]);
           });
         }
-        function result(object, path, defaultValue) {
-          path = castPath(path, object);
-          var index = -1, length = path.length;
+        function result(object, path2, defaultValue) {
+          path2 = castPath(path2, object);
+          var index = -1, length = path2.length;
           if (!length) {
             length = 1;
             object = undefined2;
           }
           while (++index < length) {
-            var value = object == null ? undefined2 : object[toKey(path[index])];
+            var value = object == null ? undefined2 : object[toKey(path2[index])];
             if (value === undefined2) {
               index = length;
               value = defaultValue;
@@ -4459,12 +4475,12 @@ var require_lodash = __commonJS({
           }
           return object;
         }
-        function set(object, path, value) {
-          return object == null ? object : baseSet(object, path, value);
+        function set(object, path2, value) {
+          return object == null ? object : baseSet(object, path2, value);
         }
-        function setWith(object, path, value, customizer) {
+        function setWith(object, path2, value, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object == null ? object : baseSet(object, path, value, customizer);
+          return object == null ? object : baseSet(object, path2, value, customizer);
         }
         var toPairs = createToPairs(keys);
         var toPairsIn = createToPairs(keysIn);
@@ -4486,15 +4502,15 @@ var require_lodash = __commonJS({
           });
           return accumulator;
         }
-        function unset(object, path) {
-          return object == null ? true : baseUnset(object, path);
+        function unset(object, path2) {
+          return object == null ? true : baseUnset(object, path2);
         }
-        function update(object, path, updater) {
-          return object == null ? object : baseUpdate(object, path, castFunction(updater));
+        function update(object, path2, updater) {
+          return object == null ? object : baseUpdate(object, path2, castFunction(updater));
         }
-        function updateWith(object, path, updater, customizer) {
+        function updateWith(object, path2, updater, customizer) {
           customizer = typeof customizer == "function" ? customizer : undefined2;
-          return object == null ? object : baseUpdate(object, path, castFunction(updater), customizer);
+          return object == null ? object : baseUpdate(object, path2, castFunction(updater), customizer);
         }
         function values(object) {
           return object == null ? [] : baseValues(object, keys(object));
@@ -4875,17 +4891,17 @@ var require_lodash = __commonJS({
         function matches(source) {
           return baseMatches(baseClone(source, CLONE_DEEP_FLAG));
         }
-        function matchesProperty(path, srcValue) {
-          return baseMatchesProperty(path, baseClone(srcValue, CLONE_DEEP_FLAG));
+        function matchesProperty(path2, srcValue) {
+          return baseMatchesProperty(path2, baseClone(srcValue, CLONE_DEEP_FLAG));
         }
-        var method = baseRest(function(path, args) {
+        var method = baseRest(function(path2, args) {
           return function(object) {
-            return baseInvoke(object, path, args);
+            return baseInvoke(object, path2, args);
           };
         });
         var methodOf = baseRest(function(object, args) {
-          return function(path) {
-            return baseInvoke(object, path, args);
+          return function(path2) {
+            return baseInvoke(object, path2, args);
           };
         });
         function mixin(object, source, options) {
@@ -4932,12 +4948,12 @@ var require_lodash = __commonJS({
         var over = createOver(arrayMap);
         var overEvery = createOver(arrayEvery);
         var overSome = createOver(arraySome);
-        function property(path) {
-          return isKey(path) ? baseProperty(toKey(path)) : basePropertyDeep(path);
+        function property(path2) {
+          return isKey(path2) ? baseProperty(toKey(path2)) : basePropertyDeep(path2);
         }
         function propertyOf(object) {
-          return function(path) {
-            return object == null ? undefined2 : baseGet(object, path);
+          return function(path2) {
+            return object == null ? undefined2 : baseGet(object, path2);
           };
         }
         var range = createRange();
@@ -5333,3146 +5349,181 @@ var require_lodash = __commonJS({
               source[methodName] = func;
             }
           });
-          return source;
-        }(), { "chain": false });
-        lodash.VERSION = VERSION;
-        arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
-          lodash[methodName].placeholder = lodash;
-        });
-        arrayEach(["drop", "take"], function(methodName, index) {
-          LazyWrapper.prototype[methodName] = function(n) {
-            n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0);
-            var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
-            if (result2.__filtered__) {
-              result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
-            } else {
-              result2.__views__.push({
-                "size": nativeMin(n, MAX_ARRAY_LENGTH),
-                "type": methodName + (result2.__dir__ < 0 ? "Right" : "")
-              });
-            }
-            return result2;
-          };
-          LazyWrapper.prototype[methodName + "Right"] = function(n) {
-            return this.reverse()[methodName](n).reverse();
-          };
-        });
-        arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
-          var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
-          LazyWrapper.prototype[methodName] = function(iteratee2) {
-            var result2 = this.clone();
-            result2.__iteratees__.push({
-              "iteratee": getIteratee(iteratee2, 3),
-              "type": type
-            });
-            result2.__filtered__ = result2.__filtered__ || isFilter;
-            return result2;
-          };
-        });
-        arrayEach(["head", "last"], function(methodName, index) {
-          var takeName = "take" + (index ? "Right" : "");
-          LazyWrapper.prototype[methodName] = function() {
-            return this[takeName](1).value()[0];
-          };
-        });
-        arrayEach(["initial", "tail"], function(methodName, index) {
-          var dropName = "drop" + (index ? "" : "Right");
-          LazyWrapper.prototype[methodName] = function() {
-            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
-          };
-        });
-        LazyWrapper.prototype.compact = function() {
-          return this.filter(identity);
-        };
-        LazyWrapper.prototype.find = function(predicate) {
-          return this.filter(predicate).head();
-        };
-        LazyWrapper.prototype.findLast = function(predicate) {
-          return this.reverse().find(predicate);
-        };
-        LazyWrapper.prototype.invokeMap = baseRest(function(path, args) {
-          if (typeof path == "function") {
-            return new LazyWrapper(this);
-          }
-          return this.map(function(value) {
-            return baseInvoke(value, path, args);
-          });
-        });
-        LazyWrapper.prototype.reject = function(predicate) {
-          return this.filter(negate(getIteratee(predicate)));
-        };
-        LazyWrapper.prototype.slice = function(start, end) {
-          start = toInteger(start);
-          var result2 = this;
-          if (result2.__filtered__ && (start > 0 || end < 0)) {
-            return new LazyWrapper(result2);
-          }
-          if (start < 0) {
-            result2 = result2.takeRight(-start);
-          } else if (start) {
-            result2 = result2.drop(start);
-          }
-          if (end !== undefined2) {
-            end = toInteger(end);
-            result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
-          }
-          return result2;
-        };
-        LazyWrapper.prototype.takeRightWhile = function(predicate) {
-          return this.reverse().takeWhile(predicate).reverse();
-        };
-        LazyWrapper.prototype.toArray = function() {
-          return this.take(MAX_ARRAY_LENGTH);
-        };
-        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
-          var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
-          if (!lodashFunc) {
-            return;
-          }
-          lodash.prototype[methodName] = function() {
-            var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value);
-            var interceptor = function(value2) {
-              var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));
-              return isTaker && chainAll ? result3[0] : result3;
-            };
-            if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
-              isLazy = useLazy = false;
-            }
-            var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
-            if (!retUnwrapped && useLazy) {
-              value = onlyLazy ? value : new LazyWrapper(this);
-              var result2 = func.apply(value, args);
-              result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined2 });
-              return new LodashWrapper(result2, chainAll);
-            }
-            if (isUnwrapped && onlyLazy) {
-              return func.apply(this, args);
-            }
-            result2 = this.thru(interceptor);
-            return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
-          };
-        });
-        arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
-          var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
-          lodash.prototype[methodName] = function() {
-            var args = arguments;
-            if (retUnwrapped && !this.__chain__) {
-              var value = this.value();
-              return func.apply(isArray(value) ? value : [], args);
-            }
-            return this[chainName](function(value2) {
-              return func.apply(isArray(value2) ? value2 : [], args);
-            });
-          };
-        });
-        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
-          var lodashFunc = lodash[methodName];
-          if (lodashFunc) {
-            var key = lodashFunc.name + "";
-            if (!hasOwnProperty.call(realNames, key)) {
-              realNames[key] = [];
-            }
-            realNames[key].push({ "name": methodName, "func": lodashFunc });
-          }
-        });
-        realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{
-          "name": "wrapper",
-          "func": undefined2
-        }];
-        LazyWrapper.prototype.clone = lazyClone;
-        LazyWrapper.prototype.reverse = lazyReverse;
-        LazyWrapper.prototype.value = lazyValue;
-        lodash.prototype.at = wrapperAt;
-        lodash.prototype.chain = wrapperChain;
-        lodash.prototype.commit = wrapperCommit;
-        lodash.prototype.next = wrapperNext;
-        lodash.prototype.plant = wrapperPlant;
-        lodash.prototype.reverse = wrapperReverse;
-        lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
-        lodash.prototype.first = lodash.prototype.head;
-        if (symIterator) {
-          lodash.prototype[symIterator] = wrapperToIterator;
-        }
-        return lodash;
-      };
-      var _2 = runInContext();
-      if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
-        root._ = _2;
-        define(function() {
-          return _2;
-        });
-      } else if (freeModule) {
-        (freeModule.exports = _2)._ = _2;
-        freeExports._ = _2;
-      } else {
-        root._ = _2;
-      }
-    }).call(exports);
-  }
-});
-
-// ../../node_modules/lazy-seq/index.js
-var require_lazy_seq = __commonJS({
-  "../../node_modules/lazy-seq/index.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var nil = {};
-    nil.isNil = true;
-    nil.toString = function() {
-      return "nil";
-    };
-    nil.length = function() {
-      return 0;
-    };
-    nil.toArray = function nilToArray() {
-      return [];
-    };
-    nil.fold = function nilFold(x) {
-      return x;
-    };
-    nil.head = function nilHead() {
-      throw new Error("nil.head");
-    };
-    nil.tail = function nilTail() {
-      return nil;
-    };
-    nil.nth = function nilNth(n) {
-      assert(typeof n === "number");
-      throw new Error("Can't get " + n + "th value of the nil");
-    };
-    nil.take = function(n) {
-      assert(typeof n === "number");
-      return nil;
-    };
-    nil.drop = function(n) {
-      assert(typeof n === "number");
-      return nil;
-    };
-    nil.map = function(f) {
-      assert(typeof f === "function");
-      return nil;
-    };
-    nil.append = function(seq) {
-      if (typeof seq === "function") {
-        seq = seq();
-      }
-      if (Array.isArray(seq)) {
-        return fromArray(seq);
-      } else {
-        return seq;
-      }
-    };
-    nil.filter = function() {
-      return nil;
-    };
-    nil.every = function() {
-      return true;
-    };
-    nil.some = function() {
-      return false;
-    };
-    nil.contains = function() {
-      return false;
-    };
-    nil.containsNot = function() {
-      return true;
-    };
-    function Cons(head, tail) {
-      this.headValue = head;
-      this.tailValue = tail;
-    }
-    Cons.prototype.isNil = false;
-    Cons.prototype.toString = function() {
-      return "Cons(" + this.headValue + ", " + this.tailValue + ")";
-    };
-    Cons.prototype.length = function() {
-      return 1 + this.tail().length();
-    };
-    Cons.prototype.toArray = function() {
-      var ptr = this;
-      var acc = [];
-      while (ptr !== nil) {
-        acc.push(ptr.headValue);
-        ptr = ptr.tail();
-      }
-      return acc;
-    };
-    Cons.prototype.fold = function consFold(x, f) {
-      var self2 = this;
-      return f(this.headValue, function() {
-        return self2.tail().fold(x, f);
-      });
-    };
-    Cons.prototype.head = function consHead() {
-      return this.headValue;
-    };
-    Cons.prototype.tail = function consTail() {
-      return this.tailValue;
-    };
-    function lazyConsForce() {
-      var val = this.tailFn();
-      this.tailValue = Array.isArray(val) ? fromArray(val) : val;
-      delete this.tail;
-      delete this.force;
-      return this;
-    }
-    function lazyConsTail() {
-      this.force();
-      return this.tailValue;
-    }
-    function delay(head, tail) {
-      assert(typeof tail === "function");
-      head.tailFn = tail;
-      head.tail = lazyConsTail;
-      head.force = lazyConsForce;
-      return head;
-    }
-    function cons(head, tail) {
-      if (typeof tail === "function") {
-        return delay(new Cons(head), tail);
-      } else if (Array.isArray(tail)) {
-        return delay(cons(head), function() {
-          return fromArray(tail);
-        });
-      } else {
-        return new Cons(head, tail);
-      }
-    }
-    Cons.prototype.nth = function consNth(n) {
-      assert(typeof n === "number");
-      return n === 0 ? this.headValue : this.tail().nth(n - 1);
-    };
-    Cons.prototype.take = function consTake(n) {
-      assert(typeof n === "number");
-      var that = this;
-      return n === 0 ? nil : cons(this.headValue, function() {
-        return that.tail().take(n - 1);
-      });
-    };
-    Cons.prototype.drop = function consDrop(n) {
-      assert(typeof n === "number");
-      return n === 0 ? this : this.tail().drop(n - 1);
-    };
-    Cons.prototype.map = function consMap(f) {
-      assert(typeof f === "function");
-      var that = this;
-      return cons(f(that.headValue), function() {
-        return that.tail().map(f);
-      });
-    };
-    Cons.prototype.append = function consAppend(seq) {
-      if (seq === nil || Array.isArray(seq) && seq.length === 0) {
-        return this;
-      }
-      var that = this;
-      return cons(that.headValue, function() {
-        return that.tail().append(seq);
-      });
-    };
-    Cons.prototype.filter = function consFilter(p) {
-      assert(typeof p === "function");
-      var that = this;
-      if (p(that.headValue)) {
-        return cons(that.headValue, function() {
-          return that.tail().filter(p);
-        });
-      } else {
-        return that.tail().filter(p);
-      }
-    };
-    Cons.prototype.every = function consEvery(p) {
-      p = p || function(x) {
-        return x;
-      };
-      assert(typeof p === "function");
-      var that = this;
-      var pHead = p(that.headValue);
-      if (!pHead) {
-        return pHead;
-      } else {
-        return that.tail().every(p);
-      }
-    };
-    Cons.prototype.some = function consSome(p) {
-      p = p || function(x) {
-        return x;
-      };
-      assert(typeof p === "function");
-      var that = this;
-      var pHead = p(that.headValue);
-      if (pHead) {
-        return pHead;
-      } else {
-        return that.tail().some(p);
-      }
-    };
-    Cons.prototype.contains = function consContains(x) {
-      var that = this;
-      if (x === that.headValue) {
-        return true;
-      } else {
-        return that.tail().contains(x);
-      }
-    };
-    Cons.prototype.containsNot = function consContainsNot(x) {
-      var that = this;
-      if (x === that.headValue) {
-        return false;
-      } else {
-        return that.tail().containsNot(x);
-      }
-    };
-    function fromArrayIter(arr, n) {
-      if (n < arr.length) {
-        return cons(arr[n], function() {
-          return fromArrayIter(arr, n + 1);
-        });
-      } else {
-        return nil;
-      }
-    }
-    function fromArray(arr) {
-      assert(Array.isArray(arr));
-      return fromArrayIter(arr, 0);
-    }
-    function singleton(x) {
-      return fromArray([x]);
-    }
-    function append() {
-      var acc = nil;
-      for (var i = 0; i < arguments.length; i++) {
-        acc = acc.append(arguments[i]);
-      }
-      return acc;
-    }
-    function iterate(x, f) {
-      return cons(x, function() {
-        return iterate(f(x), f);
-      });
-    }
-    function listFold(list, z, f, n) {
-      if (n < list.length) {
-        return f(list[n], function() {
-          return listFold(list, z, f, n + 1);
-        });
-      } else {
-        return z;
-      }
-    }
-    function fold(list, z, f) {
-      if (Array.isArray(list)) {
-        return listFold(list, z, f, 0);
-      } else {
-        return list.fold(z, f);
-      }
-    }
-    module.exports = {
-      nil,
-      cons,
-      append,
-      fromArray,
-      singleton,
-      iterate,
-      fold
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/arbitraryAssert.js
-var require_arbitraryAssert = __commonJS({
-  "../../node_modules/jsverify/lib/arbitraryAssert.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    function arbitraryAssert(arb) {
-      assert(arb !== void 0 && arb !== null && typeof arb === "object", "arb should be an object");
-      assert(
-        typeof arb.generator === "function" && typeof arb.generator.map === "function",
-        "arb.generator should be a function"
-      );
-      assert(
-        typeof arb.shrink === "function" && typeof arb.shrink.smap === "function",
-        "arb.shrink should be a function"
-      );
-      assert(typeof arb.show === "function", "arb.show should be a function");
-      assert(typeof arb.smap === "function", "arb.smap should be a function");
-    }
-    module.exports = arbitraryAssert;
-  }
-});
-
-// ../../node_modules/jsverify/lib/utils.js
-var require_utils = __commonJS({
-  "../../node_modules/jsverify/lib/utils.js"(exports, module) {
-    "use strict";
-    var isArray = Array.isArray;
-    function isObject(o) {
-      return new Object(o) === o;
-    }
-    function isNaN2(n) {
-      return typeof n === "number" && n !== n;
-    }
-    function sort(arr) {
-      var res = arr.slice();
-      res.sort();
-      return res;
-    }
-    function isEqual(a, b) {
-      var i;
-      if (isNaN2(a) && isNaN2(b)) {
-        return true;
-      }
-      if (a === b) {
-        return true;
-      } else if (isArray(a) && isArray(b) && a.length === b.length) {
-        for (i = 0; i < a.length; i++) {
-          if (!isEqual(a[i], b[i])) {
-            return false;
-          }
-        }
-        return true;
-      } else if (isObject(a) && isObject(b) && !isArray(a) && !isArray(b)) {
-        var akeys = Object.keys(a);
-        var bkeys = Object.keys(b);
-        if (!isEqual(sort(akeys), sort(bkeys))) {
-          return false;
-        }
-        for (i = 0; i < akeys.length; i++) {
-          if (!isEqual(a[akeys[i]], b[akeys[i]])) {
-            return false;
-          }
-        }
-        return true;
-      }
-      return false;
-    }
-    function isApproxEqual(x, y, opts) {
-      opts = opts || {};
-      var fnEqual = opts.fnEqual !== false;
-      var depth = opts.depth || 5;
-      var state = [];
-      function loop(a, b, n) {
-        if (isNaN2(a) && isNaN2(b)) {
-          return true;
-        }
-        if (a === b) {
-          return true;
-        }
-        if (n >= depth) {
-          return true;
-        }
-        var i;
-        for (i = 0; i < state.length; i++) {
-          if (state[i][0] === a && state[i][1] === b) {
-            return true;
-          }
-        }
-        state.push([a, b]);
-        if (typeof a === "function" && typeof b === "function") {
-          return fnEqual;
-        }
-        if (isArray(a) && isArray(b) && a.length === b.length) {
-          for (i = 0; i < a.length; i++) {
-            if (!loop(a[i], b[i], n + 1)) {
-              return false;
-            }
-          }
-          return true;
-        } else if (isObject(a) && isObject(b) && !isArray(a) && !isArray(b)) {
-          var akeys = Object.keys(a);
-          var bkeys = Object.keys(b);
-          if (!loop(sort(akeys), sort(bkeys), n + 1)) {
-            return false;
-          }
-          for (i = 0; i < akeys.length; i++) {
-            if (!loop(a[akeys[i]], b[akeys[i]], n + 1)) {
-              return false;
-            }
-          }
-          return true;
-        }
-        return false;
-      }
-      return loop(x, y, 0);
-    }
-    function identity(x) {
-      return x;
-    }
-    function pluck(arr, key) {
-      return arr.map(function(e) {
-        return e[key];
-      });
-    }
-    function force(arb) {
-      return typeof arb === "function" ? arb() : arb;
-    }
-    function merge() {
-      var res = {};
-      for (var i = 0; i < arguments.length; i++) {
-        var arg = arguments[i];
-        var keys = Object.keys(arg);
-        for (var j = 0; j < keys.length; j++) {
-          var key = keys[j];
-          res[key] = arg[key];
-        }
-      }
-      return res;
-    }
-    function div2(x) {
-      return Math.floor(x / 2);
-    }
-    function log2(x) {
-      return Math.log(x) / Math.log(2);
-    }
-    function ilog2(x) {
-      return x <= 0 ? 0 : Math.floor(log2(x));
-    }
-    function curriedN(n) {
-      var n1 = n - 1;
-      return function curriedNInstance(result, args) {
-        if (args.length === n) {
-          return result(args[n1]);
-        } else {
-          return result;
-        }
-      };
-    }
-    var curried22 = curriedN(2);
-    var curried3 = curriedN(3);
-    function charArrayToString(arr) {
-      return arr.join("");
-    }
-    function stringToCharArray(str) {
-      return str.split("");
-    }
-    function pairArrayToDict(arrayOfPairs) {
-      var res = {};
-      arrayOfPairs.forEach(function(p) {
-        res[p[0]] = p[1];
-      });
-      return res;
-    }
-    function dictToPairArray(m) {
-      var res = [];
-      Object.keys(m).forEach(function(k) {
-        res.push([k, m[k]]);
-      });
-      return res;
-    }
-    function partition(arr, pred) {
-      var truthy = [];
-      var falsy = [];
-      for (var i = 0; i < arr.length; i++) {
-        var x = arr[i];
-        if (pred(x)) {
-          truthy.push(x);
-        } else {
-          falsy.push(x);
-        }
-      }
-      return [truthy, falsy];
-    }
-    module.exports = {
-      isArray,
-      isObject,
-      isEqual,
-      isApproxEqual,
-      identity,
-      pluck,
-      force,
-      merge,
-      div2,
-      ilog2,
-      curried2: curried22,
-      curried3,
-      charArrayToString,
-      stringToCharArray,
-      pairArrayToDict,
-      dictToPairArray,
-      partition
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/show.js
-var require_show = __commonJS({
-  "../../node_modules/jsverify/lib/show.js"(exports, module) {
-    "use strict";
-    var utils = require_utils();
-    function showDef(obj) {
-      return JSON.stringify(obj);
-    }
-    function showPair(showA, showB) {
-      var result = function(p) {
-        return "(" + showA(p[0]) + ", " + showB(p[1]) + ")";
-      };
-      return utils.curried3(result, arguments);
-    }
-    function showEither(showA, showB) {
-      function showLeft(value) {
-        return "Left(" + showA(value) + ")";
-      }
-      function showRight(value) {
-        return "Right(" + showB(value) + ")";
-      }
-      var result = function(e) {
-        return e.either(showLeft, showRight);
-      };
-      return utils.curried3(result, arguments);
-    }
-    function showTuple(shows) {
-      var result = function(objs) {
-        var strs = [];
-        for (var i = 0; i < shows.length; i++) {
-          strs.push(shows[i](objs[i]));
-        }
-        return strs.join("; ");
-      };
-      return utils.curried2(result, arguments);
-    }
-    function showSum(shows) {
-      var result = function(sum) {
-        return sum.fold(function(idx, n, value) {
-          return "Sum(" + idx + "/" + n + ": " + shows[idx](value) + ")";
-        });
-      };
-      return utils.curried2(result, arguments);
-    }
-    function showArray(show) {
-      var result = function(arr) {
-        return "[" + arr.map(show).join(", ") + "]";
-      };
-      return utils.curried2(result, arguments);
-    }
-    module.exports = {
-      def: showDef,
-      pair: showPair,
-      either: showEither,
-      tuple: showTuple,
-      sum: showSum,
-      array: showArray
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/arbitraryBless.js
-var require_arbitraryBless = __commonJS({
-  "../../node_modules/jsverify/lib/arbitraryBless.js"(exports, module) {
-    "use strict";
-    var show = require_show();
-    function arbitraryProtoSMap(f, g, newShow) {
-      var arb = this;
-      return arbitraryBless({
-        generator: arb.generator.map(f),
-        shrink: arb.shrink.smap(f, g),
-        show: newShow || show.def
-      });
-    }
-    function arbitraryBless(arb) {
-      arb.smap = arbitraryProtoSMap;
-      return arb;
-    }
-    module.exports = arbitraryBless;
-  }
-});
-
-// ../../node_modules/jsverify/lib/either.js
-var require_either = __commonJS({
-  "../../node_modules/jsverify/lib/either.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    function Left(value) {
-      this.value = value;
-    }
-    function Right(value) {
-      this.value = value;
-    }
-    function left(value) {
-      return new Left(value);
-    }
-    function right(value) {
-      return new Right(value);
-    }
-    Left.prototype.either = function lefteither(l) {
-      return l(this.value);
-    };
-    Right.prototype.either = function righteither(l, r) {
-      return r(this.value);
-    };
-    Left.prototype.isEqual = function leftIsEqual(other) {
-      assert(other instanceof Left || other instanceof Right, "isEqual: `other` parameter should be either");
-      return other instanceof Left && this.value === other.value;
-    };
-    Right.prototype.isEqual = function rightIsEqual(other) {
-      assert(other instanceof Left || other instanceof Right, "isEqual: `other` parameter should be either");
-      return other instanceof Right && this.value === other.value;
-    };
-    Left.prototype.bimap = function leftBimap(f) {
-      return new Left(f(this.value));
-    };
-    Right.prototype.bimap = function rightBimap(f, g) {
-      return new Right(g(this.value));
-    };
-    Left.prototype.first = function leftFirst(f) {
-      return new Left(f(this.value));
-    };
-    Right.prototype.first = function rightFirst() {
-      return this;
-    };
-    Left.prototype.second = function leftSecond() {
-      return this;
-    };
-    Right.prototype.second = function rightSecond(g) {
-      return new Right(g(this.value));
-    };
-    module.exports = {
-      left,
-      right
-    };
-  }
-});
-
-// ../../node_modules/rc4/rc4.js
-var require_rc4 = __commonJS({
-  "../../node_modules/rc4/rc4.js"(exports, module) {
-    "use strict";
-    function isInteger(n) {
-      return parseInt(n, 10) === n;
-    }
-    function createRC4(N) {
-      function identityPermutation() {
-        var s = new Array(N);
-        for (var i = 0; i < N; i++) {
-          s[i] = i;
-        }
-        return s;
-      }
-      function seed(key) {
-        if (key === void 0) {
-          key = new Array(N);
-          for (var k = 0; k < N; k++) {
-            key[k] = Math.floor(Math.random() * N);
-          }
-        } else if (typeof key === "string") {
-          key = "" + key;
-          key = key.split("").map(function(c) {
-            return c.charCodeAt(0) % N;
-          });
-        } else if (Array.isArray(key)) {
-          if (!key.every(function(v) {
-            return typeof v === "number" && v === (v | 0);
-          })) {
-            throw new TypeError("invalid seed key specified: not array of integers");
-          }
-        } else {
-          throw new TypeError("invalid seed key specified");
-        }
-        var keylen = key.length;
-        var s = identityPermutation();
-        var j = 0;
-        for (var i = 0; i < N; i++) {
-          j = (j + s[i] + key[i % keylen]) % N;
-          var tmp = s[i];
-          s[i] = s[j];
-          s[j] = tmp;
-        }
-        return s;
-      }
-      function RC42(key) {
-        this.s = seed(key);
-        this.i = 0;
-        this.j = 0;
-      }
-      RC42.prototype.randomNative = function() {
-        this.i = (this.i + 1) % N;
-        this.j = (this.j + this.s[this.i]) % N;
-        var tmp = this.s[this.i];
-        this.s[this.i] = this.s[this.j];
-        this.s[this.j] = tmp;
-        var k = this.s[(this.s[this.i] + this.s[this.j]) % N];
-        return k;
-      };
-      RC42.prototype.randomUInt32 = function() {
-        var a = this.randomByte();
-        var b = this.randomByte();
-        var c = this.randomByte();
-        var d = this.randomByte();
-        return ((a * 256 + b) * 256 + c) * 256 + d;
-      };
-      RC42.prototype.randomFloat = function() {
-        return this.randomUInt32() / 4294967296;
-      };
-      RC42.prototype.random = function() {
-        var a;
-        var b;
-        if (arguments.length === 1) {
-          a = 0;
-          b = arguments[0];
-        } else if (arguments.length === 2) {
-          a = arguments[0];
-          b = arguments[1];
-        } else {
-          throw new TypeError("random takes one or two integer arguments");
-        }
-        if (!isInteger(a) || !isInteger(b)) {
-          throw new TypeError("random takes one or two integer arguments");
-        }
-        return a + this.randomUInt32() % (b - a + 1);
-      };
-      RC42.prototype.currentState = function() {
-        return {
-          i: this.i,
-          j: this.j,
-          s: this.s.slice()
-          // copy
-        };
-      };
-      RC42.prototype.setState = function(state) {
-        var s = state.s;
-        var i = state.i;
-        var j = state.j;
-        if (!(i === (i | 0) && 0 <= i && i < N)) {
-          throw new Error("state.i should be integer [0, " + (N - 1) + "]");
-        }
-        if (!(j === (j | 0) && 0 <= j && j < N)) {
-          throw new Error("state.j should be integer [0, " + (N - 1) + "]");
-        }
-        if (!Array.isArray(s) || s.length !== N) {
-          throw new Error("state should be array of length " + N);
-        }
-        for (var k = 0; k < N; k++) {
-          if (s.indexOf(k) === -1) {
-            throw new Error("state should be permutation of 0.." + (N - 1) + ": " + k + " is missing");
-          }
-        }
-        this.i = i;
-        this.j = j;
-        this.s = s.slice();
-      };
-      return RC42;
-    }
-    var RC4 = createRC4(256);
-    RC4.prototype.randomByte = RC4.prototype.randomNative;
-    var RC4small = createRC4(16);
-    RC4small.prototype.randomByte = function() {
-      var a = this.randomNative();
-      var b = this.randomNative();
-      return a * 16 + b;
-    };
-    var ordA = "a".charCodeAt(0);
-    var ord0 = "0".charCodeAt(0);
-    function toHex(n) {
-      return n < 10 ? String.fromCharCode(ord0 + n) : String.fromCharCode(ordA + n - 10);
-    }
-    function fromHex(c) {
-      return parseInt(c, 16);
-    }
-    RC4small.prototype.currentStateString = function() {
-      var state = this.currentState();
-      var i = toHex(state.i);
-      var j = toHex(state.j);
-      var res = i + j + state.s.map(toHex).join("");
-      return res;
-    };
-    RC4small.prototype.setStateString = function(stateString) {
-      if (!stateString.match(/^[0-9a-f]{18}$/)) {
-        throw new TypeError("RC4small stateString should be 18 hex character string");
-      }
-      var i = fromHex(stateString[0]);
-      var j = fromHex(stateString[1]);
-      var s = stateString.split("").slice(2).map(fromHex);
-      this.setState({
-        i,
-        j,
-        s
-      });
-    };
-    RC4.RC4small = RC4small;
-    module.exports = RC4;
-  }
-});
-
-// ../../node_modules/jsverify/lib/random.js
-var require_random = __commonJS({
-  "../../node_modules/jsverify/lib/random.js"(exports, module) {
-    "use strict";
-    var rc4 = new (require_rc4()).RC4small();
-    function randomInteger(min, max) {
-      return rc4.random(min, max);
-    }
-    function randomNumber(min, max) {
-      return rc4.randomFloat() * (max - min) + min;
-    }
-    randomInteger.integer = randomInteger;
-    randomInteger.number = randomNumber;
-    randomInteger.currentStateString = rc4.currentStateString.bind(rc4);
-    randomInteger.setStateString = rc4.setStateString.bind(rc4);
-    module.exports = randomInteger;
-  }
-});
-
-// ../../node_modules/jsverify/lib/sum.js
-var require_sum = __commonJS({
-  "../../node_modules/jsverify/lib/sum.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    function Addend(idx, len, value) {
-      assert(len > 0, "Addend: 0 < len");
-      assert(idx >= 0 && idx < len, "Addend: 0 <= idx < len");
-      this.idx = idx;
-      this.len = len;
-      this.value = value;
-    }
-    function addend(idx, len, value) {
-      return new Addend(idx, len, value);
-    }
-    Addend.prototype.fold = function(f) {
-      return f(this.idx, this.len, this.value);
-    };
-    module.exports = {
-      addend
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/generator.js
-var require_generator = __commonJS({
-  "../../node_modules/jsverify/lib/generator.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var either = require_either();
-    var random = require_random();
-    var sum = require_sum();
-    var utils = require_utils();
-    function generatorProtoMap(f) {
-      var generator = this;
-      generatorAssert(generator);
-      return generatorBless(function(size) {
-        return f(generator(size));
-      });
-    }
-    function generatorProtoFlatMap(f) {
-      var generator = this;
-      generatorAssert(generator);
-      return generatorBless(function(size) {
-        return f(generator(size))(size);
-      });
-    }
-    function generatorAssert(generator) {
-      assert(typeof generator === "function", "generator should be a function");
-      assert(generator.map === generatorProtoMap, "generator.map should be a function");
-      assert(generator.flatmap === generatorProtoFlatMap, "generator.flatmap should be a function");
-      assert(generator.flatMap === generatorProtoFlatMap, "generator.flatMap should be a function");
-    }
-    function generatorBless(generator) {
-      generator.map = generatorProtoMap;
-      generator.flatmap = generatorProtoFlatMap;
-      generator.flatMap = generatorProtoFlatMap;
-      return generator;
-    }
-    function generateConstant(x) {
-      return generatorBless(function() {
-        return x;
-      });
-    }
-    function generatorCombine() {
-      var generators = Array.prototype.slice.call(arguments, 0, -1);
-      var f = arguments[arguments.length - 1];
-      return generatorBless(function(size) {
-        var values = generators.map(function(gen) {
-          return gen(size);
-        });
-        return f.apply(void 0, values);
-      });
-    }
-    function generateOneof(generators) {
-      generators.forEach(function(gen) {
-        assert(typeof gen === "function");
-      });
-      var result = generatorBless(function(size) {
-        var idx = random(0, generators.length - 1);
-        var gen = generators[idx];
-        return gen(size);
-      });
-      return utils.curried2(result, arguments);
-    }
-    function logsize(size) {
-      return Math.max(Math.round(Math.log(size + 1) / Math.log(2), 0));
-    }
-    function generatorRecursive(genZ, genS) {
-      return generatorBless(function(size) {
-        function rec(n, sizep) {
-          if (n <= 0 || random(0, 3) === 0) {
-            return genZ(sizep);
-          } else {
-            return genS(generatorBless(function(sizeq) {
-              return rec(n - 1, sizeq);
-            }))(sizep);
-          }
-        }
-        return rec(logsize(size), size);
-      });
-    }
-    function generatePair(genA, genB) {
-      var result = generatorBless(function(size) {
-        return [genA(size), genB(size)];
-      });
-      return utils.curried3(result, arguments);
-    }
-    function generateEither(genA, genB) {
-      var result = generatorBless(function(size) {
-        var n = random(0, 1);
-        switch (n) {
-          case 0:
-            return either.left(genA(size));
-          case 1:
-            return either.right(genB(size));
-        }
-      });
-      return utils.curried3(result, arguments);
-    }
-    var generateUnit = generatorBless(function() {
-      return [];
-    });
-    function generateTuple(gens) {
-      var len = gens.length;
-      var result = generatorBless(function(size) {
-        var r = [];
-        for (var i = 0; i < len; i++) {
-          r[i] = gens[i](size);
-        }
-        return r;
-      });
-      return utils.curried2(result, arguments);
-    }
-    function generateSum(gens) {
-      var len = gens.length;
-      var result = generatorBless(function(size) {
-        var idx = random(0, len - 1);
-        return sum.addend(idx, len, gens[idx](size));
-      });
-      return utils.curried2(result, arguments);
-    }
-    function generateArray(gen) {
-      var result = generatorBless(function(size) {
-        var arrsize = random(0, logsize(size));
-        var arr = new Array(arrsize);
-        for (var i = 0; i < arrsize; i++) {
-          arr[i] = gen(size);
-        }
-        return arr;
-      });
-      return utils.curried2(result, arguments);
-    }
-    function generateNEArray(gen) {
-      var result = generatorBless(function(size) {
-        var arrsize = random(1, Math.max(logsize(size), 1));
-        var arr = new Array(arrsize);
-        for (var i = 0; i < arrsize; i++) {
-          arr[i] = gen(size);
-        }
-        return arr;
-      });
-      return utils.curried2(result, arguments);
-    }
-    module.exports = {
-      pair: generatePair,
-      either: generateEither,
-      unit: generateUnit,
-      tuple: generateTuple,
-      sum: generateSum,
-      array: generateArray,
-      nearray: generateNEArray,
-      oneof: generateOneof,
-      constant: generateConstant,
-      bless: generatorBless,
-      combine: generatorCombine,
-      recursive: generatorRecursive
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/shrink.js
-var require_shrink = __commonJS({
-  "../../node_modules/jsverify/lib/shrink.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var either = require_either();
-    var lazyseq2 = require_lazy_seq();
-    var sum = require_sum();
-    var utils = require_utils();
-    function shrinkProtoIsoMap(f, g) {
-      var shrink = this;
-      return shrinkBless(function(value) {
-        return shrink(g(value)).map(f);
-      });
-    }
-    function shrinkBless(shrink) {
-      shrink.smap = shrinkProtoIsoMap;
-      return shrink;
-    }
-    var shrinkNoop = shrinkBless(function shrinkNoop2() {
-      return [];
-    });
-    function shrinkPair(shrinkA, shrinkB) {
-      var result = shrinkBless(function(pair) {
-        assert(pair.length === 2, "shrinkPair: pair should be an Array of length 2");
-        var a = pair[0];
-        var b = pair[1];
-        var shrinkedA = shrinkA(a);
-        var shrinkedB = shrinkB(b);
-        var pairA = shrinkedA.map(function(ap) {
-          return [ap, b];
-        });
-        if (Array.isArray(pairA)) {
-          pairA = lazyseq2.fromArray(pairA);
-        }
-        return pairA.append(function() {
-          var pairB = shrinkedB.map(function(bp) {
-            return [a, bp];
-          });
-          return pairB;
-        });
-      });
-      return utils.curried3(result, arguments);
-    }
-    function shrinkEither(shrinkA, shrinkB) {
-      function shrinkLeft(value) {
-        return shrinkA(value).map(either.left);
-      }
-      function shrinkRight(value) {
-        return shrinkB(value).map(either.right);
-      }
-      var result = shrinkBless(function(e) {
-        return e.either(shrinkLeft, shrinkRight);
-      });
-      return utils.curried3(result, arguments);
-    }
-    function fromLinkedList(ll) {
-      assert(ll.length === 1 || ll.length === 2, "linked list must be either [] or [x, linkedlist]");
-      if (ll.length === 1) {
-        return [ll[0]];
-      } else {
-        return [ll[0]].concat(fromLinkedList(ll[1]));
-      }
-    }
-    function toLinkedList(arr) {
-      assert(Array.isArray(arr) && arr.length > 0, "toLinkedList expects non-empty array");
-      if (arr.length === 1) {
-        return [arr[0]];
-      } else {
-        return [arr[0], toLinkedList(arr.slice(1))];
-      }
-    }
-    function toSingleton(x) {
-      return [x];
-    }
-    function fromSingleton(a) {
-      return a[0];
-    }
-    function flattenShrink(shrinksLL) {
-      if (shrinksLL.length === 1) {
-        return shrinksLL[0].smap(toSingleton, fromSingleton);
-      } else {
-        var head = shrinksLL[0];
-        var tail = shrinksLL[1];
-        return shrinkPair(head, flattenShrink(tail));
-      }
-    }
-    function shrinkTuple(shrinks) {
-      assert(shrinks.length > 0, "shrinkTuple needs > 0 values");
-      var shrinksLL = toLinkedList(shrinks);
-      var shrink = flattenShrink(shrinksLL);
-      var result = shrinkBless(function(tuple) {
-        assert(tuple.length === shrinks.length, "shrinkTuple: not-matching params");
-        var ll = toLinkedList(tuple);
-        return shrink(ll).map(fromLinkedList);
-      });
-      return utils.curried2(result, arguments);
-    }
-    function shrinkSum(shrinks) {
-      assert(shrinks.length > 0, "shrinkTuple needs > 0 values");
-      var result = shrinkBless(function(s) {
-        return s.fold(function(idx, len, value) {
-          assert(len === shrinks.length, "shrinkSum: not-matching params");
-          return shrinks[idx](value).map(function(shrinked) {
-            return sum.addend(idx, len, shrinked);
-          });
-        });
-      });
-      return utils.curried2(result, arguments);
-    }
-    function shrinkArrayWithMinimumSize2(size) {
-      function shrinkArrayImpl(shrink) {
-        var result = shrinkBless(function(arr) {
-          assert(Array.isArray(arr), "shrinkArrayImpl() expects array, got: " + arr);
-          if (arr.length <= size) {
-            return lazyseq2.nil;
-          } else {
-            var x = arr[0];
-            var xs = arr.slice(1);
-            return lazyseq2.cons(xs, lazyseq2.nil).append(shrink(x).map(function(xp) {
-              return [xp].concat(xs);
-            })).append(shrinkArrayImpl(shrink, xs).map(function(xsp) {
-              return [x].concat(xsp);
-            }));
-          }
-        });
-        return utils.curried2(result, arguments);
-      }
-      return shrinkArrayImpl;
-    }
-    var shrinkArray = shrinkArrayWithMinimumSize2(0);
-    var shrinkNEArray = shrinkArrayWithMinimumSize2(1);
-    module.exports = {
-      noop: shrinkNoop,
-      pair: shrinkPair,
-      either: shrinkEither,
-      tuple: shrinkTuple,
-      sum: shrinkSum,
-      array: shrinkArray,
-      nearray: shrinkNEArray,
-      bless: shrinkBless
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/array.js
-var require_array = __commonJS({
-  "../../node_modules/jsverify/lib/array.js"(exports, module) {
-    "use strict";
-    var arbitraryAssert = require_arbitraryAssert();
-    var arbitraryBless = require_arbitraryBless();
-    var generator = require_generator();
-    var show = require_show();
-    var shrink = require_shrink();
-    var utils = require_utils();
-    function makeArray(flavour) {
-      return function arrayImpl(arb) {
-        arb = utils.force(arb);
-        arbitraryAssert(arb);
-        return arbitraryBless({
-          generator: generator[flavour](arb.generator),
-          shrink: shrink[flavour](arb.shrink),
-          show: show.array(arb.show)
-        });
-      };
-    }
-    var array = makeArray("array");
-    var nearray = makeArray("nearray");
-    module.exports = {
-      array,
-      nearray
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/pair.js
-var require_pair = __commonJS({
-  "../../node_modules/jsverify/lib/pair.js"(exports, module) {
-    "use strict";
-    var arbitraryAssert = require_arbitraryAssert();
-    var arbitraryBless = require_arbitraryBless();
-    var generator = require_generator();
-    var show = require_show();
-    var shrink = require_shrink();
-    var utils = require_utils();
-    function pair(a, b) {
-      a = utils.force(a);
-      b = utils.force(b);
-      arbitraryAssert(a);
-      arbitraryAssert(b);
-      return arbitraryBless({
-        generator: generator.pair(a.generator, b.generator),
-        shrink: shrink.pair(a.shrink, b.shrink),
-        show: show.pair(a.show, b.show)
-      });
-    }
-    module.exports = {
-      pair
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/primitive.js
-var require_primitive = __commonJS({
-  "../../node_modules/jsverify/lib/primitive.js"(exports, module) {
-    "use strict";
-    var arbitraryBless = require_arbitraryBless();
-    var assert = __require("assert");
-    var generator = require_generator();
-    var random = require_random();
-    var show = require_show();
-    var shrink = require_shrink();
-    var utils = require_utils();
-    function extendWithDefault(arb) {
-      var def = arb();
-      arb.generator = def.generator;
-      arb.shrink = def.shrink;
-      arb.show = def.show;
-      arb.smap = def.smap;
-    }
-    function numeric(impl) {
-      return function(minsize, maxsize) {
-        if (arguments.length === 2) {
-          var arb = arbitraryBless(impl(maxsize - minsize));
-          var to = function to2(x) {
-            return Math.abs(x) + minsize;
-          };
-          var from = function from2(x) {
-            return x - minsize;
-          };
-          return arb.smap(to, from);
-        } else if (arguments.length === 1) {
-          return arbitraryBless(impl(
-            minsize
-            /* as maxsize */
-          ));
-        } else {
-          return arbitraryBless(impl());
-        }
-      };
-    }
-    var integer = numeric(function integer2(maxsize) {
-      return {
-        generator: generator.bless(function(size) {
-          size = maxsize === void 0 ? size : maxsize;
-          return random(-size, size);
-        }),
-        shrink: shrink.bless(function(i) {
-          assert(typeof i === "number", "integer.shrink have to be a number");
-          i = Math.abs(i);
-          if (i === 0) {
-            return [];
-          } else {
-            var arr = [0];
-            var j = utils.div2(i);
-            var k = Math.max(j, 1);
-            while (j < i) {
-              arr.push(j);
-              arr.push(-j);
-              k = Math.max(utils.div2(k), 1);
-              j += k;
-            }
-            return arr;
-          }
-        }),
-        show: show.def
-      };
-    });
-    extendWithDefault(integer);
-    function nat(maxsize) {
-      return arbitraryBless({
-        generator: generator.bless(function(size) {
-          size = maxsize === void 0 ? size : maxsize;
-          return random(0, size);
-        }),
-        shrink: shrink.bless(function(i) {
-          assert(typeof i === "number", "nat.shrink have to be a number");
-          var arr = [];
-          var j = utils.div2(i);
-          var k = Math.max(j, 1);
-          while (j < i) {
-            arr.push(j);
-            k = Math.max(utils.div2(k), 1);
-            j += k;
-          }
-          return arr;
-        }),
-        show: show.def
-      });
-    }
-    extendWithDefault(nat);
-    var number = numeric(function number2(maxsize) {
-      return {
-        generator: generator.bless(function(size) {
-          size = maxsize === void 0 ? size : maxsize;
-          return random.number(-size, size);
-        }),
-        shrink: shrink.bless(function(x) {
-          assert(typeof x === "number", "number.shrink have to be a number");
-          if (Math.abs(x) > 1e-6) {
-            return [0, x / 2, -x / 2];
-          } else {
-            return [];
-          }
-        }),
-        show: show.def
-      };
-    });
-    extendWithDefault(number);
-    var uint8 = nat(255);
-    var uint16 = nat(65535);
-    var uint32 = nat(4294967295);
-    var int8 = integer(-128, 127);
-    var int16 = integer(-32768, 32767);
-    var int32 = integer(-2147483648, 2147483647);
-    var bool = arbitraryBless({
-      generator: generator.bless(function() {
-        var i = random(0, 1);
-        return i === 1;
-      }),
-      shrink: shrink.bless(function(b) {
-        assert(b === true || b === false, "bool.shrink excepts true or false");
-        return b === true ? [false] : [];
-      }),
-      show: show.def
-    });
-    var datetimeConst = 1416499879495;
-    function datetime(from, to) {
-      var toDate;
-      var fromDate;
-      var arb;
-      if (arguments.length === 2) {
-        toDate = function toDateFn(x) {
-          return new Date(x);
-        };
-        fromDate = function fromDateFn(x) {
-          return x.getTime();
-        };
-        from = fromDate(from);
-        to = fromDate(to);
-        arb = number(from, to);
-        return arb.smap(toDate, fromDate);
-      } else {
-        toDate = function toDateFn(x) {
-          return new Date(x * 768e6 + datetimeConst);
-        };
-        arb = number;
-        return arbitraryBless({
-          generator: arb.generator.map(toDate),
-          shrink: shrink.noop,
-          show: show.def
-        });
-      }
-    }
-    extendWithDefault(datetime);
-    function elements(args) {
-      assert(args.length !== 0, "elements: at least one parameter expected");
-      return arbitraryBless({
-        generator: generator.bless(function() {
-          var i = random(0, args.length - 1);
-          return args[i];
-        }),
-        shrink: shrink.bless(function(x) {
-          var idx = args.indexOf(x);
-          if (idx <= 0) {
-            return [];
-          } else {
-            return args.slice(0, idx);
-          }
-        }),
-        show: show.def
-      });
-    }
-    var falsy = elements([false, null, void 0, "", 0, NaN]);
-    falsy.show = function(v) {
-      if (v !== v) {
-        return "falsy: NaN";
-      } else if (v === "") {
-        return "falsy: empty string";
-      } else if (v === void 0) {
-        return "falsy: undefined";
-      } else {
-        return "falsy: " + v;
-      }
-    };
-    function constant(x) {
-      return arbitraryBless({
-        generator: generator.constant(x),
-        shrink: shrink.noop,
-        show: show.def
-      });
-    }
-    module.exports = {
-      integer,
-      nat,
-      int8,
-      int16,
-      int32,
-      uint8,
-      uint16,
-      uint32,
-      number,
-      elements,
-      bool,
-      falsy,
-      constant,
-      datetime
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/string.js
-var require_string = __commonJS({
-  "../../node_modules/jsverify/lib/string.js"(exports, module) {
-    "use strict";
-    var array = require_array();
-    var primitive = require_primitive();
-    var utils = require_utils();
-    function fromCode2(code) {
-      return String.fromCharCode(code);
-    }
-    function toCode2(c) {
-      return c.charCodeAt(0);
-    }
-    var char = primitive.nat(255).smap(fromCode2, toCode2);
-    var asciichar = primitive.integer(32, 126).smap(fromCode2, toCode2);
-    var string = array.array(char).smap(utils.charArrayToString, utils.stringToCharArray);
-    var nestring = array.nearray(char).smap(utils.charArrayToString, utils.stringToCharArray);
-    var asciistring = array.array(asciichar).smap(utils.charArrayToString, utils.stringToCharArray);
-    var asciinestring = array.nearray(asciichar).smap(utils.charArrayToString, utils.stringToCharArray);
-    module.exports = {
-      char,
-      asciichar,
-      string,
-      nestring,
-      asciistring,
-      asciinestring
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/dict.js
-var require_dict = __commonJS({
-  "../../node_modules/jsverify/lib/dict.js"(exports, module) {
-    "use strict";
-    var arbitraryAssert = require_arbitraryAssert();
-    var array = require_array();
-    var generator = require_generator();
-    var pair = require_pair();
-    var string = require_string();
-    var utils = require_utils();
-    function makeMapShow(elShow) {
-      return function(m) {
-        return "{" + Object.keys(m).map(function(k) {
-          return k + ": " + elShow(m[k]);
-        }).join(", ") + "}";
-      };
-    }
-    function generateDict(gen) {
-      var pairGen = generator.pair(string.string.generator, gen);
-      var arrayGen = generator.array(pairGen);
-      var result = arrayGen.map(utils.pairArrayToDict);
-      return utils.curried2(result, arguments);
-    }
-    function dict(arb) {
-      arb = utils.force(arb);
-      arbitraryAssert(arb);
-      var pairArbitrary = pair.pair(string.string, arb);
-      var arrayArbitrary = array.array(pairArbitrary);
-      return arrayArbitrary.smap(utils.pairArrayToDict, utils.dictToPairArray, makeMapShow(arb.show));
-    }
-    module.exports = {
-      arbitrary: dict,
-      generator: generateDict
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/json.js
-var require_json = __commonJS({
-  "../../node_modules/jsverify/lib/json.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var arbitraryBless = require_arbitraryBless();
-    var dict = require_dict();
-    var generator = require_generator();
-    var primitive = require_primitive();
-    var show = require_show();
-    var shrink = require_shrink();
-    var string = require_string();
-    var utils = require_utils();
-    var nullArb = primitive.constant(null);
-    var generateInteger = primitive.integer.generator;
-    var generateNumber = primitive.number.generator;
-    var generateBool = primitive.bool.generator;
-    var generateString = string.string.generator;
-    var generateNull = nullArb.generator;
-    var generateJson = generator.recursive(
-      generator.oneof([
-        generateInteger,
-        generateNumber,
-        generateBool,
-        generateString,
-        generateNull
-      ]),
-      function(gen) {
-        return generator.oneof([generator.array(gen), dict.generator(gen)]);
-      }
-    );
-    var shrinkDictJson;
-    var shrinkJson;
-    function shrinkRecJson(json2) {
-      if (Array.isArray(json2)) {
-        return shrink.array(shrinkJson, json2);
-      } else {
-        return shrinkDictJson(json2);
-      }
-    }
-    shrinkJson = shrink.bless(function(json2) {
-      assert(typeof json2 !== "function");
-      if (json2 === null) {
-        return nullArb.shrink(json2);
-      }
-      switch (typeof json2) {
-        case "boolean":
-          return primitive.bool.shrink(json2);
-        case "number":
-          return primitive.number.shrink(json2);
-        case "string":
-          return string.string.shrink(json2);
-        default:
-          return shrinkRecJson(json2);
-      }
-    });
-    shrinkDictJson = function() {
-      var pairShrink = shrink.pair(string.string.shrink, shrinkJson);
-      var arrayShrink = shrink.array(pairShrink);
-      return arrayShrink.smap(utils.pairArrayToDict, utils.dictToPairArray);
-    }();
-    var json = arbitraryBless({
-      generator: generateJson,
-      shrink: shrinkJson,
-      show: show.def
-    });
-    module.exports = {
-      json
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/arbitrary.js
-var require_arbitrary = __commonJS({
-  "../../node_modules/jsverify/lib/arbitrary.js"(exports, module) {
-    "use strict";
-    var arbitraryAssert = require_arbitraryAssert();
-    var arbitraryBless = require_arbitraryBless();
-    var array = require_array();
-    var assert = __require("assert");
-    var dict = require_dict();
-    var generator = require_generator();
-    var json = require_json();
-    var pair = require_pair();
-    var show = require_show();
-    var shrink = require_shrink();
-    var utils = require_utils();
-    function nonshrink(arb) {
-      arb = utils.force(arb);
-      return arbitraryBless({
-        generator: arb.generator,
-        shrink: shrink.noop,
-        show: arb.show
-      });
-    }
-    var unit = arbitraryBless({
-      generator: generator.unit,
-      shrink: shrink.noop,
-      show: show.def
-    });
-    function either(a, b) {
-      a = utils.force(a || json.json);
-      b = utils.force(b || json.json);
-      arbitraryAssert(a);
-      arbitraryAssert(b);
-      return arbitraryBless({
-        generator: generator.either(a.generator, b.generator),
-        shrink: shrink.either(a.shrink, b.shrink),
-        show: show.either(a.show, b.show)
-      });
-    }
-    function pairArb(a, b) {
-      return pair.pair(a || json.json, b || json.json);
-    }
-    function tuple(arbs) {
-      arbs = arbs.map(utils.force);
-      return arbitraryBless({
-        generator: generator.tuple(utils.pluck(arbs, "generator")),
-        shrink: shrink.tuple(utils.pluck(arbs, "shrink")),
-        show: show.tuple(utils.pluck(arbs, "show"))
-      });
-    }
-    function sum(arbs) {
-      arbs = arbs.map(utils.force);
-      return arbitraryBless({
-        generator: generator.sum(utils.pluck(arbs, "generator")),
-        shrink: shrink.sum(utils.pluck(arbs, "shrink")),
-        show: show.sum(utils.pluck(arbs, "show"))
-      });
-    }
-    function dictArb(arb) {
-      return dict.arbitrary(arb || json.json);
-    }
-    function arrayArb(arb) {
-      return array.array(arb || json.json);
-    }
-    function nearrayArb(arb) {
-      return array.nearray(arb || json.json);
-    }
-    var jsonArb = json.json;
-    function oneof() {
-      assert(arguments.length !== 0, "oneof: at least one parameter expected");
-      var generators = [];
-      var append = function(a) {
-        generators.push(utils.force(a).generator);
-      };
-      for (var i = 0; i < arguments.length; i++) {
-        var arg = arguments[i];
-        if (utils.isArray(arg)) {
-          arg.forEach(append);
-        } else {
-          append(arg);
-        }
-      }
-      return arbitraryBless({
-        generator: generator.oneof(generators),
-        // TODO: make shrink
-        shrink: shrink.noop,
-        show: show.def
-      });
-    }
-    function lazyArbitrary() {
-      var arb = {};
-      arb.generator = generator.bless(function(size) {
-        return arb.strict.generator(size);
-      });
-      arb.shrink = shrink.noop;
-      arb.show = show.def;
-      arb = arbitraryBless(arb);
-      return arb;
-    }
-    function letrec(definition) {
-      var lazyArbs = {};
-      function tie(name) {
-        if (!lazyArbs.hasOwnProperty(name)) {
-          lazyArbs[name] = lazyArbitrary();
-        }
-        return lazyArbs[name];
-      }
-      var strictArbs = definition(tie);
-      Object.keys(lazyArbs).forEach(function(key) {
-        var strictArb = strictArbs[key];
-        if (!strictArb) {
-          throw new Error("undefined lazy arbitrary: " + key);
-        }
-        lazyArbs[key].strict = strictArb;
-      });
-      return strictArbs;
-    }
-    function recursive(arbZ, arbS) {
-      var genZ = arbZ.generator;
-      var genS = function(recGen) {
-        var recArb = arbitraryBless({
-          generator: recGen,
-          shrink: shrink.noop,
-          show: show.def
-        });
-        return arbS(recArb).generator;
-      };
-      var gen = generator.recursive(genZ, genS);
-      return arbitraryBless({
-        generator: gen,
-        shrink: shrink.noop,
-        show: show.def
-      });
-    }
-    module.exports = {
-      nonshrink,
-      pair: pairArb,
-      either,
-      unit,
-      dict: dictArb,
-      json: jsonArb,
-      nearray: nearrayArb,
-      array: arrayArb,
-      tuple,
-      sum,
-      oneof,
-      recursive,
-      letrec
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/bless.js
-var require_bless = __commonJS({
-  "../../node_modules/jsverify/lib/bless.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var arbitraryBless = require_arbitraryBless();
-    var generator = require_generator();
-    var show = require_show();
-    var shrink = require_shrink();
-    function bless(arb) {
-      assert(arb !== null && typeof arb === "object", "bless: arb should be an object");
-      assert(typeof arb.generator === "function", "bless: arb.generator should be a function");
-      if (typeof arb.shrink !== "function") {
-        arb.shrink = shrink.noop;
-      }
-      if (typeof arb.show !== "function") {
-        arb.show = show.def;
-      }
-      generator.bless(arb.generator);
-      shrink.bless(arb.shrink);
-      arbitraryBless(arb);
-      return arb;
-    }
-    module.exports = bless;
-  }
-});
-
-// ../../node_modules/jsverify/lib/record.js
-var require_record = __commonJS({
-  "../../node_modules/jsverify/lib/record.js"(exports, module) {
-    "use strict";
-    var arbitraryBless = require_arbitraryBless();
-    var generator = require_generator();
-    var utils = require_utils();
-    var shrink = require_shrink();
-    function generatorRecord(spec) {
-      var keys = Object.keys(spec);
-      var result = generator.bless(function(size) {
-        var res = {};
-        keys.forEach(function(k) {
-          res[k] = spec[k](size);
-        });
-        return res;
-      });
-      return utils.curried2(result, arguments);
-    }
-    function shrinkRecord(shrinksRecord) {
-      var keys = Object.keys(shrinksRecord);
-      var shrinks = keys.map(function(k) {
-        return shrinksRecord[k];
-      });
-      var result = shrink.bless(function(rec) {
-        var values = keys.map(function(k) {
-          return rec[k];
-        });
-        var shrinked = shrink.tuple(shrinks, values);
-        return shrinked.map(function(s) {
-          var res = {};
-          keys.forEach(function(k, i) {
-            res[k] = s[i];
-          });
-          return res;
-        });
-      });
-      return utils.curried2(result, arguments);
-    }
-    function arbitraryRecord(spec) {
-      var generatorSpec = {};
-      var shrinkSpec = {};
-      var showSpec = {};
-      Object.keys(spec).forEach(function(k) {
-        var arb = utils.force(spec[k]);
-        generatorSpec[k] = arb.generator;
-        shrinkSpec[k] = arb.shrink;
-        showSpec[k] = arb.show;
-      });
-      return arbitraryBless({
-        generator: generatorRecord(generatorSpec),
-        shrink: shrinkRecord(shrinkSpec),
-        show: function(m) {
-          return "{" + Object.keys(m).map(function(k) {
-            return k + ": " + showSpec[k](m[k]);
-          }).join(", ") + "}";
-        }
-      });
-    }
-    module.exports = {
-      generator: generatorRecord,
-      arbitrary: arbitraryRecord,
-      shrink: shrinkRecord
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/finitemap.js
-var require_finitemap = __commonJS({
-  "../../node_modules/jsverify/lib/finitemap.js"(exports, module) {
-    "use strict";
-    var utils = require_utils();
-    function FMap(eq) {
-      this.eq = eq || utils.isEqual;
-      this.data = [];
-    }
-    FMap.prototype.contains = function FMapContains(key) {
-      for (var i = 0; i < this.data.length; i++) {
-        if (this.eq(this.data[i][0], key)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    FMap.prototype.insert = function FMapInsert(key, value) {
-      for (var i = 0; i < this.data.length; i++) {
-        if (this.eq(this.data[i][0], key)) {
-          this.data[i] = [key, value];
-          return;
-        }
-      }
-      this.data.push([key, value]);
-    };
-    FMap.prototype.get = function FMapGet(key) {
-      for (var i = 0; i < this.data.length; i++) {
-        if (this.eq(this.data[i][0], key)) {
-          return this.data[i][1];
-        }
-      }
-    };
-    module.exports = FMap;
-  }
-});
-
-// ../../node_modules/jsverify/lib/fn.js
-var require_fn = __commonJS({
-  "../../node_modules/jsverify/lib/fn.js"(exports, module) {
-    "use strict";
-    var arbitraryBless = require_arbitraryBless();
-    var generator = require_generator();
-    var FMap = require_finitemap();
-    var json = require_json();
-    var shrink = require_shrink();
-    var utils = require_utils();
-    function fn(arb) {
-      arb = utils.force(arb || json.json);
-      return arbitraryBless({
-        generator: generator.bless(function(size) {
-          var m = new FMap();
-          var f = function(arg) {
-            if (!m.contains(arg)) {
-              var value = arb.generator(size);
-              m.insert(arg, value);
-            }
-            return m.get(arg);
-          };
-          f.internalMap = m;
-          return f;
-        }),
-        shrink: shrink.noop,
-        show: function(f) {
-          return "[" + f.internalMap.data.map(function(item) {
-            return "" + item[0] + ": " + arb.show(item[1]);
-          }).join(", ") + "]";
-        }
-      });
-    }
-    module.exports = {
-      fn,
-      fun: fn
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/small.js
-var require_small = __commonJS({
-  "../../node_modules/jsverify/lib/small.js"(exports, module) {
-    "use strict";
-    var generator = require_generator();
-    var arbitraryBless = require_arbitraryBless();
-    var arbitraryAssert = require_arbitraryAssert();
-    var utils = require_utils();
-    function smallGenerator(gen) {
-      return generator.bless(function(size) {
-        return gen(utils.ilog2(size));
-      });
-    }
-    function smallArbitraryImpl(arb) {
-      arbitraryAssert(arb);
-      return arbitraryBless({
-        generator: smallGenerator(arb.generator),
-        shrink: arb.shrink,
-        show: arb.show
-      });
-    }
-    function smallArbitrary(arb) {
-      if (typeof arb === "function") {
-        return function() {
-          var resArb = arb.apply(arb, arguments);
-          return smallArbitraryImpl(resArb);
-        };
-      } else {
-        return smallArbitraryImpl(arb);
-      }
-    }
-    module.exports = {
-      generator: smallGenerator,
-      arbitrary: smallArbitrary
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/environment.js
-var require_environment = __commonJS({
-  "../../node_modules/jsverify/lib/environment.js"(exports, module) {
-    "use strict";
-    var arbitrary = require_arbitrary();
-    var fn = require_fn();
-    var primitive = require_primitive();
-    var small = require_small();
-    var string = require_string();
-    var utils = require_utils();
-    var environment = utils.merge(primitive, string, {
-      pair: arbitrary.pair,
-      unit: arbitrary.unit,
-      either: arbitrary.either,
-      dict: arbitrary.dict,
-      array: arbitrary.array,
-      nearray: arbitrary.nearray,
-      json: arbitrary.json,
-      fn: fn.fn,
-      fun: fn.fn,
-      nonshrink: arbitrary.nonshrink,
-      small: small.arbitrary
-    });
-    module.exports = environment;
-  }
-});
-
-// ../../node_modules/typify-parser/lib/parser.js
-var require_parser = __commonJS({
-  "../../node_modules/typify-parser/lib/parser.js"(exports, module) {
-    "use strict";
-    function unescapeString(str) {
-      return str.replace(/\\(?:'|"|\\|n|x[0-9a-fA-F]{2})/g, function(match) {
-        switch (match[1]) {
-          case "'":
-            return "'";
-          case '"':
-            return '"';
-          case "\\":
-            return "\\";
-          case "n":
-            return "\n";
-          case "x":
-            return String.fromCharCode(parseInt(match.substr(2), 16));
-        }
-      });
-    }
-    function lex(input) {
-      var m = input.match(/^([ \t\r\n]+|[\u22a4\u22a5\u2227\u2228\u00d7\u2192\u2026]|\ud835\udfd9|_\|_|\*|\(\)|"(?:[^"\\]|\\[\\'"n]|\\x[0-9a-fA-F]{2})*"|'(?:[^'\\]|\\[\\'"n]|\\x[0-9a-fA-F]{2})*'|[0-9a-zA-Z_\$@]+|,|->|:|;|&|\||\.\.\.|\(|\)|\[|\]|\{|\}|\?)*$/);
-      if (m === null) {
-        throw new SyntaxError("Cannot lex type signature");
-      }
-      m = input.match(/([ \t\r\n]+|[\u22a4\u22a5\u2227\u2228\u00d7\u2192\u2026]|\ud835\udfd9|_\|_|\*|\(\)|"(?:[^"\\]|\\[\\'"n]|\\x[0-9a-fA-F]{2})*"|'(?:[^'\\]|\\[\\'"n]|\\x[0-9a-fA-F]{2})*'|[0-9a-zA-Z_\$@]+|,|->|:|;|&|\||\.\.\.|\(|\)|\[|\]|\{|\}|\?)/g);
-      return m.map(function(token) {
-        switch (token) {
-          case "_|_":
-            return { type: "false" };
-          case "\u22A5":
-            return { type: "false" };
-          case "*":
-            return { type: "true" };
-          case "\u22A4":
-            return { type: "true" };
-          case "()":
-            return { type: "unit" };
-          case "\u{1D7D9}":
-            return { type: "unit" };
-          case "true":
-            return { type: "bool", value: true };
-          case "false":
-            return { type: "bool", value: false };
-          case "rec":
-            return { type: "rec" };
-          case "&":
-            return { type: "&" };
-          case "\u2227":
-            return { type: "&" };
-          case "|":
-            return { type: "|" };
-          case "\u2228":
-            return { type: "|" };
-          case ",":
-            return { type: "," };
-          case "\xD7":
-            return { type: "," };
-          case ";":
-            return { type: ";" };
-          case ":":
-            return { type: ":" };
-          case "(":
-            return { type: "(" };
-          case ")":
-            return { type: ")" };
-          case "[":
-            return { type: "[" };
-          case "]":
-            return { type: "]" };
-          case "{":
-            return { type: "{" };
-          case "}":
-            return { type: "}" };
-          case "?":
-            return { type: "?" };
-          case "->":
-            return { type: "->" };
-          case "\u2192":
-            return { type: "->" };
-          case "...":
-            return { type: "..." };
-          case "\u2026":
-            return { type: "..." };
-        }
-        if (token.match(/^[ \r\r\n]+$/)) {
-          return null;
-        }
-        if (token.match(/^[0-9]+/)) {
-          return { type: "number", value: parseInt(token, 10) };
-        }
-        if (token[0] === "'" || token[0] === '"') {
-          token = token.slice(1, -1);
-          return { type: "string", value: unescapeString(token) };
-        }
-        return { type: "ident", value: token };
-      }).filter(function(token) {
-        return token !== null;
-      });
-    }
-    function makePunctParser(type) {
-      return function(state) {
-        if (state.pos >= state.len) {
-          throw new SyntaxError("Expecting identifier, end-of-input found");
-        }
-        var token = state.tokens[state.pos];
-        if (token.type !== type) {
-          throw new SyntaxError("Expecting '" + type + "', found: " + token.type);
-        }
-        state.pos += 1;
-        return type;
-      };
-    }
-    var colonParser = makePunctParser(":");
-    var openCurlyParser = makePunctParser("{");
-    var closeCurlyParser = makePunctParser("}");
-    var semicolonParser = makePunctParser(";");
-    var openParenParser = makePunctParser("(");
-    var closeParenParser = makePunctParser(")");
-    var openBracketParser = makePunctParser("[");
-    var closeBracketParser = makePunctParser("]");
-    var recKeywordParser = makePunctParser("rec");
-    var arrowParser = makePunctParser("->");
-    function nameParser(state) {
-      if (state.pos >= state.len) {
-        throw new SyntaxError("Expecting identifier, end-of-input found");
-      }
-      var token = state.tokens[state.pos];
-      if (token.type !== "ident") {
-        throw new SyntaxError("Expecting 'ident', found: " + token.type);
-      }
-      state.pos += 1;
-      return token.value;
-    }
-    function recursiveParser(state) {
-      recKeywordParser(state);
-      var name = nameParser(state);
-      arrowParser(state);
-      var value = typeParser(state);
-      return {
-        type: "recursive",
-        name,
-        arg: value
-      };
-    }
-    function recordParser(state) {
-      openCurlyParser(state);
-      var token = state.tokens[state.pos];
-      if (token && token.type === "}") {
-        closeCurlyParser(state);
-        return { type: "record", fields: {} };
-      }
-      var fields = {};
-      while (true) {
-        var name = nameParser(state);
-        colonParser(state);
-        var value = typeParser(state);
-        fields[name] = value;
-        token = state.tokens[state.pos];
-        if (token && token.type === "}") {
-          closeCurlyParser(state);
-          break;
-        } else if (token && token.type === ";") {
-          semicolonParser(state);
-        } else {
-          throw new SyntaxError("Expecting '}' or ';', found: " + token.type);
-        }
-      }
-      return { type: "record", fields };
-    }
-    function postfix(parser, postfixToken, constructor) {
-      return function(state) {
-        var arg = parser(state);
-        var token = state.tokens[state.pos];
-        if (token && token.type === postfixToken) {
-          state.pos += 1;
-          return {
-            type: constructor,
-            arg
-          };
-        } else {
-          return arg;
-        }
-      };
-    }
-    var optionalParser = postfix(terminalParser, "?", "optional");
-    function applicationParser(state) {
-      var rator = optionalParser(state);
-      var rands = [];
-      while (true) {
-        var pos = state.pos;
-        try {
-          var arg = optionalParser(state);
-          rands.push(arg);
-        } catch (err) {
-          state.pos = pos;
-          break;
-        }
-      }
-      if (rands.length === 0) {
-        return rator;
-      } else {
-        return {
-          type: "application",
-          callee: rator,
-          args: rands
-        };
-      }
-    }
-    function separatedBy(parser, separator, constructor) {
-      return function(state) {
-        var list = [parser(state)];
-        while (true) {
-          var token = state.tokens[state.pos];
-          if (token && token.type === separator) {
-            state.pos += 1;
-          } else {
-            break;
-          }
-          list.push(parser(state));
-        }
-        if (list.length === 1) {
-          return list[0];
-        } else {
-          return {
-            type: constructor,
-            args: list
-          };
-        }
-      };
-    }
-    var conjunctionParser = separatedBy(applicationParser, "&", "conjunction");
-    var disjunctionParser = separatedBy(conjunctionParser, "|", "disjunction");
-    var variadicParser = postfix(disjunctionParser, "...", "variadic");
-    function namedParser(state) {
-      var token1 = state.tokens[state.pos];
-      var token2 = state.tokens[state.pos + 1];
-      if (token1 && token2 && token1.type === "ident" && token2.type === ":") {
-        state.pos += 2;
-        var arg = namedParser(state);
-        return {
-          type: "named",
-          name: token1.value,
-          arg
-        };
-      } else {
-        return variadicParser(state);
-      }
-    }
-    var productParser = separatedBy(namedParser, ",", "product");
-    function functionParser(state) {
-      var v = productParser(state);
-      var token = state.tokens[state.pos];
-      if (token && token.type === "->") {
-        state.pos += 1;
-        var result = functionParser(state);
-        return {
-          type: "function",
-          arg: v,
-          result
-        };
-      } else {
-        return v;
-      }
-    }
-    function typeParser(state) {
-      return functionParser(state);
-    }
-    function parenthesesParser(state) {
-      openParenParser(state);
-      var type = typeParser(state);
-      closeParenParser(state);
-      return type;
-    }
-    function bracketParser(state) {
-      openBracketParser(state);
-      var type = typeParser(state);
-      closeBracketParser(state);
-      return {
-        type: "brackets",
-        arg: type
-      };
-    }
-    function terminalParser(state) {
-      if (state.pos >= state.len) {
-        throw new SyntaxError("Expecting terminal, end-of-input found");
-      }
-      var token = state.tokens[state.pos];
-      switch (token.type) {
-        case "false":
-        case "true":
-        case "unit":
-        case "string":
-        case "number":
-        case "bool":
-        case "ident":
-          state.pos += 1;
-          return token;
-        case "{":
-          return recordParser(state);
-        case "(":
-          return parenthesesParser(state);
-        case "[":
-          return bracketParser(state);
-        case "rec":
-          return recursiveParser(state);
-        default:
-          throw new SyntaxError("Expecting terminal, " + token.type + " found");
-      }
-    }
-    function parse(input) {
-      var tokens = lex(input);
-      var state = {
-        pos: 0,
-        len: tokens.length,
-        tokens
-      };
-      var res = typeParser(state);
-      if (state.pos !== state.len) {
-        throw new SyntaxError("expecting end-of-input, " + tokens[state.pos].type + " found");
-      }
-      return res;
-    }
-    function recordFreeVars(fields) {
-      var res = [];
-      for (var k in fields) {
-        var t = fields[k];
-        res = res.concat(freeVarsImpl(t));
-      }
-      return res;
-    }
-    function concatFreeVars(ts) {
-      var res = [];
-      for (var i = 0; i < ts.length; i++) {
-        var t = ts[i];
-        res = res.concat(freeVarsImpl(t));
-      }
-      return res;
-    }
-    function freeVarsImpl(t) {
-      switch (t.type) {
-        case "false":
-        case "true":
-        case "unit":
-        case "string":
-        case "number":
-        case "bool":
-          return [];
-        case "ident":
-          return [t.value];
-        case "record":
-          return recordFreeVars(t.fields);
-        case "named":
-          return freeVarsImpl(t.arg);
-        case "conjunction":
-          return concatFreeVars(t.args);
-        case "disjunction":
-          return concatFreeVars(t.args);
-        case "product":
-          return concatFreeVars(t.args);
-        case "recursive":
-          return freeVarsImpl(t.arg).filter(function(n) {
-            return n !== t.name;
-          });
-        case "optional":
-          return freeVarsImpl(t.arg);
-        case "brackets":
-          return freeVarsImpl(t.arg);
-        case "variadic":
-          return freeVarsImpl(t.arg);
-        case "application":
-          return freeVarsImpl(t.callee).concat(concatFreeVars(t.args));
-        case "function":
-          return freeVarsImpl(t.arg).concat(freeVarsImpl(t.result));
-      }
-    }
-    function uniq(arr) {
-      var res = [];
-      for (var i = 0; i < arr.length; i++) {
-        var x = arr[i];
-        if (res.indexOf(x) === -1) {
-          res.push(x);
-        }
-      }
-      return res;
-    }
-    function freeVars(t) {
-      var fvs = freeVarsImpl(t);
-      fvs.sort();
-      return uniq(fvs);
-    }
-    parse.freeVars = freeVars;
-    module.exports = parse;
-  }
-});
-
-// ../../node_modules/jsverify/lib/typify.js
-var require_typify = __commonJS({
-  "../../node_modules/jsverify/lib/typify.js"(exports, module) {
-    "use strict";
-    var arbitrary = require_arbitrary();
-    var assert = __require("assert");
-    var record = require_record();
-    var array = require_array();
-    var fn = require_fn();
-    var typifyParser = require_parser();
-    var utils = require_utils();
-    var compileType;
-    var compileTypeArray;
-    function compileIdent(env, type) {
-      var g = env[type.value];
-      if (!g) {
-        throw new Error("Unknown arbitrary: " + type.value);
-      }
-      return g;
-    }
-    function compileApplication(env, type) {
-      var callee = compileType(env, type.callee);
-      var args = compileTypeArray(env, type.args);
-      return callee.apply(void 0, args);
-    }
-    function compileFunction(env, type) {
-      var result = compileType(env, type.result);
-      return fn.fn(result);
-    }
-    function compileBrackets(env, type) {
-      var arg = compileType(env, type.arg);
-      return array.array(arg);
-    }
-    function compileDisjunction(env, type) {
-      var args = compileTypeArray(env, type.args);
-      return arbitrary.sum(args);
-    }
-    function compileConjunction(env, type) {
-      var args = compileTypeArray(env, type.args);
-      return arbitrary.tuple(args);
-    }
-    function compileRecord(env, type) {
-      var spec = {};
-      Object.keys(type.fields).forEach(function(key) {
-        spec[key] = compileType(env, type.fields[key]);
-      });
-      return record.arbitrary(spec);
-    }
-    function compileRecursive(env, type) {
-      assert(type.arg.type === "disjunction", "recursive type's argument should be disjunction");
-      var name = type.name;
-      var par = utils.partition(type.arg.args, function(t) {
-        return typifyParser.freeVars(t).indexOf(name) === -1;
-      });
-      var terminal = par[0];
-      if (terminal.length === 0) {
-        throw new Error("Recursive type without non-recursive branch");
-      }
-      var terminalArb = compileType(env, {
-        type: "disjunction",
-        args: terminal
-      });
-      return arbitrary.recursive(terminalArb, function(arb) {
-        var arbEnv = {};
-        arbEnv[name] = arb;
-        var newEnv = utils.merge(env, arbEnv);
-        return compileType(newEnv, type.arg);
-      });
-    }
-    compileType = function compileTypeFn(env, type) {
-      switch (type.type) {
-        case "ident":
-          return compileIdent(env, type);
-        case "application":
-          return compileApplication(env, type);
-        case "function":
-          return compileFunction(env, type);
-        case "brackets":
-          return compileBrackets(env, type);
-        case "disjunction":
-          return compileDisjunction(env, type);
-        case "conjunction":
-          return compileConjunction(env, type);
-        case "record":
-          return compileRecord(env, type);
-        case "number":
-          return type.value;
-        case "recursive":
-          return compileRecursive(env, type);
-        default:
-          throw new Error("Unsupported typify ast type: " + type.type);
-      }
-    };
-    compileTypeArray = function compileTypeArrayFn(env, types) {
-      return types.map(function(type) {
-        return compileType(env, type);
-      });
-    };
-    function parseTypify(env, str) {
-      var type = typifyParser(str);
-      return compileType(env, type);
-    }
-    module.exports = {
-      parseTypify
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/recordWithEnv.js
-var require_recordWithEnv = __commonJS({
-  "../../node_modules/jsverify/lib/recordWithEnv.js"(exports, module) {
-    "use strict";
-    var environment = require_environment();
-    var record = require_record();
-    var typify = require_typify();
-    var utils = require_utils();
-    function recordWithEnv(spec, userenv) {
-      var env = userenv ? utils.merge(environment, userenv) : environment;
-      var parsedSpec = {};
-      Object.keys(spec).forEach(function(k) {
-        var arb = spec[k];
-        parsedSpec[k] = typeof arb === "string" ? typify.parseTypify(env, arb) : arb;
-      });
-      return record.arbitrary(parsedSpec);
-    }
-    module.exports = recordWithEnv;
-  }
-});
-
-// ../../node_modules/jsverify/lib/api.js
-var require_api = __commonJS({
-  "../../node_modules/jsverify/lib/api.js"(exports, module) {
-    "use strict";
-    var arbitrary = require_arbitrary();
-    var bless = require_bless();
-    var dict = require_dict();
-    var generator = require_generator();
-    var json = require_json();
-    var primitive = require_primitive();
-    var record = require_record();
-    var recordWithEnv = require_recordWithEnv();
-    var shrink = require_shrink();
-    var small = require_small();
-    var string = require_string();
-    var api = {
-      arbitrary: {
-        small: small.arbitrary,
-        bless,
-        record: recordWithEnv,
-        nonshrink: arbitrary.nonshrink,
-        pair: arbitrary.pair,
-        either: arbitrary.either,
-        unit: arbitrary.unit,
-        dict: arbitrary.dict,
-        json: arbitrary.json,
-        nearray: arbitrary.nearray,
-        array: arbitrary.array,
-        tuple: arbitrary.tuple,
-        sum: arbitrary.sum,
-        oneof: arbitrary.oneof,
-        recursive: arbitrary.recursive,
-        letrec: arbitrary.letrec
-      },
-      generator: {
-        dict: dict.generator,
-        json: json.json.generator,
-        small: small.generator,
-        record: record.generator
-      },
-      shrink: {
-        record: record.shrink
-      }
-    };
-    var k;
-    for (k in primitive) {
-      api.arbitrary[k] = primitive[k];
-    }
-    for (k in string) {
-      api.arbitrary[k] = string[k];
-    }
-    for (k in shrink) {
-      api.shrink[k] = shrink[k];
-    }
-    for (k in generator) {
-      api.generator[k] = generator[k];
-    }
-    module.exports = api;
-  }
-});
-
-// ../../node_modules/trampa/index.js
-var require_trampa = __commonJS({
-  "../../node_modules/trampa/index.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    function Done(x) {
-      this.x = x;
-    }
-    function Cont(tramp, cont) {
-      assert(typeof cont === "function");
-      this.tramp = tramp;
-      this.cont = cont;
-    }
-    function isTrampoline(t) {
-      return t instanceof Done || t instanceof Cont;
-    }
-    function wrap(t) {
-      return isTrampoline(t) ? t : new Done(t);
-    }
-    function lazy(computation) {
-      assert(typeof computation === "function", "lazy: computation should be function");
-      return wrap().jump(computation);
-    }
-    Done.prototype.jump = function(f) {
-      return new Cont(this, function(x) {
-        return wrap(f(x));
-      });
-    };
-    Cont.prototype.jump = Done.prototype.jump;
-    function execute(curr, params) {
-      params = params || {};
-      var debug = params.debug || false;
-      var log = params.log || console.log;
-      var stack = [];
-      while (true) {
-        if (debug) {
-          log("trampoline execute: stack size " + stack.length);
-        }
-        if (curr instanceof Done) {
-          if (stack.length === 0) {
-            return curr.x;
-          } else {
-            curr = stack[stack.length - 1](curr.x);
-            stack.pop();
-          }
-        } else {
-          assert(curr instanceof Cont);
-          stack.push(curr.cont);
-          curr = curr.tramp;
-        }
-      }
-    }
-    Done.prototype.run = Cont.prototype.run = function(params) {
-      return execute(this, params);
-    };
-    module.exports = {
-      isTrampoline,
-      wrap,
-      lazy
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/functor.js
-var require_functor = __commonJS({
-  "../../node_modules/jsverify/lib/functor.js"(exports, module) {
-    "use strict";
-    var trampa = require_trampa();
-    function isPromise(p) {
-      return new Object(p) === p && typeof p.then === "function";
-    }
-    function map(p, g) {
-      if (isPromise(p)) {
-        return p.then(function(x) {
-          return map(x, g);
+          return source;
+        }(), { "chain": false });
+        lodash.VERSION = VERSION;
+        arrayEach(["bind", "bindKey", "curry", "curryRight", "partial", "partialRight"], function(methodName) {
+          lodash[methodName].placeholder = lodash;
         });
-      } else if (trampa.isTrampoline(p)) {
-        return p.jump(function(x) {
-          return map(x, g);
+        arrayEach(["drop", "take"], function(methodName, index) {
+          LazyWrapper.prototype[methodName] = function(n) {
+            n = n === undefined2 ? 1 : nativeMax(toInteger(n), 0);
+            var result2 = this.__filtered__ && !index ? new LazyWrapper(this) : this.clone();
+            if (result2.__filtered__) {
+              result2.__takeCount__ = nativeMin(n, result2.__takeCount__);
+            } else {
+              result2.__views__.push({
+                "size": nativeMin(n, MAX_ARRAY_LENGTH),
+                "type": methodName + (result2.__dir__ < 0 ? "Right" : "")
+              });
+            }
+            return result2;
+          };
+          LazyWrapper.prototype[methodName + "Right"] = function(n) {
+            return this.reverse()[methodName](n).reverse();
+          };
         });
-      } else {
-        return g(p);
-      }
-    }
-    function bind(f, xs, h) {
-      var r;
-      var exc;
-      try {
-        r = f.apply(void 0, xs);
-      } catch (e) {
-        r = false;
-        exc = e;
-      }
-      if (isPromise(r)) {
-        return r.then(
-          h,
-          function(e) {
-            return h(false, e);
-          }
-        );
-      } else {
-        return h(r, exc);
-      }
-    }
-    function run(x) {
-      if (isPromise(x)) {
-        return x.then(run);
-      } else if (trampa.isTrampoline(x)) {
-        return run(x.run());
-      } else {
-        return x;
-      }
-    }
-    function pure(x) {
-      if (isPromise(x)) {
-        return x;
-      } else {
-        return trampa.wrap(x);
-      }
-    }
-    module.exports = {
-      isPromise,
-      map,
-      pure,
-      bind,
-      run
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/suchthat.js
-var require_suchthat = __commonJS({
-  "../../node_modules/jsverify/lib/suchthat.js"(exports, module) {
-    "use strict";
-    var environment = require_environment();
-    var typify = require_typify();
-    var utils = require_utils();
-    var generator = require_generator();
-    var shrink = require_shrink();
-    var arbitraryBless = require_arbitraryBless();
-    function suchthat(arb, userenv, predicate) {
-      var env;
-      if (arguments.length === 2) {
-        predicate = userenv;
-        env = environment;
-      } else {
-        env = utils.merge(environment, userenv);
-      }
-      arb = typeof arb === "string" ? typify.parseTypify(env, arb) : arb;
-      arb = utils.force(arb);
-      return arbitraryBless({
-        generator: generator.bless(function(size) {
-          for (var i = 0; ; i++) {
-            if (i > 5) {
-              i = 0;
-              size += 1;
-            }
-            var x = arb.generator(size);
-            if (predicate(x)) {
-              return x;
-            }
-          }
-        }),
-        shrink: shrink.bless(function(x) {
-          return arb.shrink(x).filter(predicate);
-        }),
-        show: arb.show
-      });
-    }
-    module.exports = {
-      suchthat
-    };
-  }
-});
-
-// ../../node_modules/jsverify/lib/jsverify.js
-var require_jsverify = __commonJS({
-  "../../node_modules/jsverify/lib/jsverify.js"(exports, module) {
-    "use strict";
-    var assert = __require("assert");
-    var lazyseq2 = require_lazy_seq();
-    var api = require_api();
-    var either = require_either();
-    var environment = require_environment();
-    var FMap = require_finitemap();
-    var fn = require_fn();
-    var functor = require_functor();
-    var random = require_random();
-    var show = require_show();
-    var shrink = require_shrink();
-    var suchthat = require_suchthat();
-    var sum = require_sum();
-    var typify = require_typify();
-    var utils = require_utils();
-    function shrinkResult(arbs, x, test, size, shrinksN, exc, transform) {
-      assert(arbs.length === x.length, "shrinkResult: arbs and x has to be of same size");
-      assert(typeof size === "number", "shrinkResult: size should be number");
-      assert(typeof shrinksN === "number", "shrinkResult: shrinkN should be number");
-      var shrinks = utils.pluck(arbs, "shrink");
-      var shows = utils.pluck(arbs, "show");
-      var shrinked = shrink.tuple(shrinks, x);
-      var shrinkP = lazyseq2.fold(shrinked, true, function(y, rest) {
-        var t = test(size, y, shrinksN + 1);
-        return functor.map(t, function(tprime) {
-          return tprime !== true ? tprime : rest();
+        arrayEach(["filter", "map", "takeWhile"], function(methodName, index) {
+          var type = index + 1, isFilter = type == LAZY_FILTER_FLAG || type == LAZY_WHILE_FLAG;
+          LazyWrapper.prototype[methodName] = function(iteratee2) {
+            var result2 = this.clone();
+            result2.__iteratees__.push({
+              "iteratee": getIteratee(iteratee2, 3),
+              "type": type
+            });
+            result2.__filtered__ = result2.__filtered__ || isFilter;
+            return result2;
+          };
         });
-      });
-      return functor.map(shrinkP, function(shrinkPPrime) {
-        if (shrinkPPrime === true) {
-          var res = {
-            counterexample: x,
-            counterexamplestr: show.tuple(shows, x),
-            shrinks: shrinksN,
-            exc
+        arrayEach(["head", "last"], function(methodName, index) {
+          var takeName = "take" + (index ? "Right" : "");
+          LazyWrapper.prototype[methodName] = function() {
+            return this[takeName](1).value()[0];
           };
-          return transform(res);
-        } else {
-          return shrinkPPrime;
-        }
-      });
-    }
-    function isArbitrary(arb) {
-      return (typeof arb === "object" || typeof arb === "function") && typeof arb.generator === "function" && typeof arb.shrink === "function" && typeof arb.show === "function";
-    }
-    function forall() {
-      var args = Array.prototype.slice.call(arguments);
-      var gens = args.slice(0, -1);
-      var property = args[args.length - 1];
-      var env;
-      var lastgen = gens[gens.length - 1];
-      if (!isArbitrary(lastgen) && typeof lastgen !== "string") {
-        env = utils.merge(environment, lastgen);
-        gens = gens.slice(0, -1);
-      } else {
-        env = environment;
-      }
-      assert(gens.length > 0, "forall requires at least single generator");
-      gens = gens.map(function(g) {
-        g = typeof g === "string" ? typify.parseTypify(env, g) : g;
-        return utils.force(g);
-      });
-      assert(typeof property === "function", "property should be a function");
-      function test(size, x, shrinks) {
-        assert(Array.isArray(x), "generators results should be always tuple");
-        return functor.bind(property, x, function(r, exc) {
-          if (r === true) {
-            return true;
-          } else if (typeof r === "function") {
-            var rRec = r(size);
-            return functor.map(rRec, function(rRecPrime) {
-              if (rRecPrime === true) {
-                return true;
-              } else {
-                return shrinkResult(gens, x, test, size, shrinks, exc, function(rr) {
-                  return {
-                    counterexample: rr.counterexample.concat(rRecPrime.counterexample),
-                    counterexamplestr: rr.counterexamplestr,
-                    // + "; " + rRec.counterexamplestr,
-                    shrinks: rr.shrinks,
-                    exc: rr.exc || rRecPrime.exc
-                  };
-                });
-              }
-            });
-          } else {
-            return shrinkResult(gens, x, test, size, shrinks, exc || r, utils.identity);
-          }
         });
-      }
-      return function(size) {
-        var x = gens.map(function(arb) {
-          return arb.generator(size);
+        arrayEach(["initial", "tail"], function(methodName, index) {
+          var dropName = "drop" + (index ? "" : "Right");
+          LazyWrapper.prototype[methodName] = function() {
+            return this.__filtered__ ? new LazyWrapper(this) : this[dropName](1);
+          };
         });
-        var r = test(size, x, 0);
-        return r;
-      };
-    }
-    function formatFailedCase(r, state, includeStack) {
-      var msg = "Failed after " + r.tests + " tests and " + r.shrinks + " shrinks. ";
-      msg += "rngState: " + (r.rngState || state) + "; ";
-      msg += "Counterexample: " + r.counterexamplestr + "; ";
-      if (r.exc) {
-        if (r.exc instanceof Error) {
-          msg += "Exception: " + r.exc.message;
-          if (includeStack) {
-            msg += "\nStack trace: " + r.exc.stack;
-          }
-        } else {
-          msg += "Error: " + r.exc;
-        }
-      }
-      return msg;
-    }
-    function findRngState(argv) {
-      for (var i = 0; i < argv.length - 1; i++) {
-        if (argv[i] === "--jsverifyRngState") {
-          return argv[i + 1];
-        }
-      }
-    }
-    function check(property, opts) {
-      opts = opts || {};
-      opts.size = opts.size || 50;
-      opts.tests = opts.tests || 100;
-      opts.quiet = opts.quiet || false;
-      assert(typeof property === "function", "property should be a function");
-      var state;
-      if (opts.rngState) {
-        random.setStateString(opts.rngState);
-      } else if (typeof process !== "undefined") {
-        var argvState = findRngState(process.argv);
-        if (argvState) {
-          random.setStateString(argvState);
-        }
-      }
-      function loop(i) {
-        state = random.currentStateString();
-        if (i > opts.tests) {
-          return true;
-        }
-        var size = random(0, opts.size);
-        var r = functor.pure(property(size));
-        return functor.map(r, function(rPrime) {
-          if (rPrime === true) {
-            return loop(i + 1);
-          } else {
-            rPrime.tests = i;
-            if (!opts.quiet) {
-              console.error(formatFailedCase(rPrime, state, true), rPrime.counterexample);
-            }
-            return rPrime;
+        LazyWrapper.prototype.compact = function() {
+          return this.filter(identity);
+        };
+        LazyWrapper.prototype.find = function(predicate) {
+          return this.filter(predicate).head();
+        };
+        LazyWrapper.prototype.findLast = function(predicate) {
+          return this.reverse().find(predicate);
+        };
+        LazyWrapper.prototype.invokeMap = baseRest(function(path2, args) {
+          if (typeof path2 == "function") {
+            return new LazyWrapper(this);
           }
+          return this.map(function(value) {
+            return baseInvoke(value, path2, args);
+          });
         });
-      }
-      return functor.run(functor.map(loop(1), function(r) {
-        if (r === true) {
-          if (!opts.quiet) {
-            console.info("OK, passed " + opts.tests + " tests");
+        LazyWrapper.prototype.reject = function(predicate) {
+          return this.filter(negate(getIteratee(predicate)));
+        };
+        LazyWrapper.prototype.slice = function(start, end) {
+          start = toInteger(start);
+          var result2 = this;
+          if (result2.__filtered__ && (start > 0 || end < 0)) {
+            return new LazyWrapper(result2);
           }
-        } else {
-          r.rngState = state;
-        }
-        return r;
-      }));
-    }
-    function checkThrow(property, opts) {
-      opts = opts || {};
-      if (opts.quiet === void 0) {
-        opts.quiet = true;
-      }
-      return functor.run(functor.map(check(property, opts), function(r) {
-        if (r !== true) {
-          if (r.exc instanceof Error) {
-            r.exc.message = formatFailedCase(r);
-            throw r.exc;
-          } else {
-            throw new Error(formatFailedCase(r));
+          if (start < 0) {
+            result2 = result2.takeRight(-start);
+          } else if (start) {
+            result2 = result2.drop(start);
           }
-        }
-      }));
-    }
-    function bddProperty(name) {
-      var args = Array.prototype.slice.call(arguments, 1);
-      if (args.length === 1) {
-        it(name, function() {
-          return functor.run(functor.map(args[0](), function(result) {
-            if (typeof result === "function") {
-              return checkThrow(result);
-            } else if (result !== true) {
-              throw new Error(name + " doesn't hold");
+          if (end !== undefined2) {
+            end = toInteger(end);
+            result2 = end < 0 ? result2.dropRight(-end) : result2.take(end - start);
+          }
+          return result2;
+        };
+        LazyWrapper.prototype.takeRightWhile = function(predicate) {
+          return this.reverse().takeWhile(predicate).reverse();
+        };
+        LazyWrapper.prototype.toArray = function() {
+          return this.take(MAX_ARRAY_LENGTH);
+        };
+        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
+          var checkIteratee = /^(?:filter|find|map|reject)|While$/.test(methodName), isTaker = /^(?:head|last)$/.test(methodName), lodashFunc = lodash[isTaker ? "take" + (methodName == "last" ? "Right" : "") : methodName], retUnwrapped = isTaker || /^find/.test(methodName);
+          if (!lodashFunc) {
+            return;
+          }
+          lodash.prototype[methodName] = function() {
+            var value = this.__wrapped__, args = isTaker ? [1] : arguments, isLazy = value instanceof LazyWrapper, iteratee2 = args[0], useLazy = isLazy || isArray(value);
+            var interceptor = function(value2) {
+              var result3 = lodashFunc.apply(lodash, arrayPush([value2], args));
+              return isTaker && chainAll ? result3[0] : result3;
+            };
+            if (useLazy && checkIteratee && typeof iteratee2 == "function" && iteratee2.length != 1) {
+              isLazy = useLazy = false;
+            }
+            var chainAll = this.__chain__, isHybrid = !!this.__actions__.length, isUnwrapped = retUnwrapped && !chainAll, onlyLazy = isLazy && !isHybrid;
+            if (!retUnwrapped && useLazy) {
+              value = onlyLazy ? value : new LazyWrapper(this);
+              var result2 = func.apply(value, args);
+              result2.__actions__.push({ "func": thru, "args": [interceptor], "thisArg": undefined2 });
+              return new LodashWrapper(result2, chainAll);
+            }
+            if (isUnwrapped && onlyLazy) {
+              return func.apply(this, args);
             }
-          }));
+            result2 = this.thru(interceptor);
+            return isUnwrapped ? isTaker ? result2.value()[0] : result2.value() : result2;
+          };
         });
-      } else {
-        var prop = forall.apply(void 0, args);
-        it(name, function() {
-          return checkThrow(prop);
+        arrayEach(["pop", "push", "shift", "sort", "splice", "unshift"], function(methodName) {
+          var func = arrayProto[methodName], chainName = /^(?:push|sort|unshift)$/.test(methodName) ? "tap" : "thru", retUnwrapped = /^(?:pop|shift)$/.test(methodName);
+          lodash.prototype[methodName] = function() {
+            var args = arguments;
+            if (retUnwrapped && !this.__chain__) {
+              var value = this.value();
+              return func.apply(isArray(value) ? value : [], args);
+            }
+            return this[chainName](function(value2) {
+              return func.apply(isArray(value2) ? value2 : [], args);
+            });
+          };
         });
-      }
-    }
-    function compile(str, env) {
-      env = env ? utils.merge(environment, env) : environment;
-      return typify.parseTypify(env, str);
-    }
-    function sampler(arb, size) {
-      size = typeof size === "number" ? Math.abs(size) : 10;
-      return function(count) {
-        if (typeof count === "number") {
-          var acc = [];
-          count = Math.abs(count);
-          for (var i = 0; i < count; i++) {
-            acc.push(arb.generator(size));
+        baseForOwn(LazyWrapper.prototype, function(func, methodName) {
+          var lodashFunc = lodash[methodName];
+          if (lodashFunc) {
+            var key = lodashFunc.name + "";
+            if (!hasOwnProperty.call(realNames, key)) {
+              realNames[key] = [];
+            }
+            realNames[key].push({ "name": methodName, "func": lodashFunc });
           }
-          return acc;
-        } else {
-          return arb.generator(size);
+        });
+        realNames[createHybrid(undefined2, WRAP_BIND_KEY_FLAG).name] = [{
+          "name": "wrapper",
+          "func": undefined2
+        }];
+        LazyWrapper.prototype.clone = lazyClone;
+        LazyWrapper.prototype.reverse = lazyReverse;
+        LazyWrapper.prototype.value = lazyValue;
+        lodash.prototype.at = wrapperAt;
+        lodash.prototype.chain = wrapperChain;
+        lodash.prototype.commit = wrapperCommit;
+        lodash.prototype.next = wrapperNext;
+        lodash.prototype.plant = wrapperPlant;
+        lodash.prototype.reverse = wrapperReverse;
+        lodash.prototype.toJSON = lodash.prototype.valueOf = lodash.prototype.value = wrapperValue;
+        lodash.prototype.first = lodash.prototype.head;
+        if (symIterator) {
+          lodash.prototype[symIterator] = wrapperToIterator;
         }
+        return lodash;
       };
-    }
-    function throws(block, error, message) {
-      assert(error === void 0 || typeof error === "function", "throws: error parameter must be a constructor");
-      assert(message === void 0 || typeof message === "string", "throws: message parameter must be a string");
-      try {
-        block();
-        return false;
-      } catch (e) {
-        if (error !== void 0) {
-          if (e instanceof error) {
-            return message === void 0 || e.message === message;
-          } else {
-            return false;
-          }
-        } else {
-          return true;
-        }
-      }
-    }
-    function assertForall() {
-      return checkThrow(forall.apply(null, arguments));
-    }
-    function checkForall() {
-      return check(forall.apply(null, arguments));
-    }
-    var jsc2 = {
-      forall,
-      check,
-      assert: checkThrow,
-      assertForall,
-      checkForall,
-      property: bddProperty,
-      sampler,
-      throws,
-      // generators
-      fn: fn.fn,
-      fun: fn.fn,
-      suchthat: suchthat.suchthat,
-      // either
-      left: either.left,
-      right: either.right,
-      // sum
-      addend: sum.addend,
-      // compile
-      compile,
-      generator: api.generator,
-      shrink: api.shrink,
-      // internal utility lib
-      random,
-      show,
-      utils,
-      _: {
-        FMap
+      var _2 = runInContext();
+      if (typeof define == "function" && typeof define.amd == "object" && define.amd) {
+        root._ = _2;
+        define(function() {
+          return _2;
+        });
+      } else if (freeModule) {
+        (freeModule.exports = _2)._ = _2;
+        freeExports._ = _2;
+      } else {
+        root._ = _2;
       }
-    };
-    for (k in api.arbitrary) {
-      jsc2[k] = api.arbitrary[k];
-    }
-    var k;
-    module.exports = jsc2;
+    }).call(exports);
   }
 });
 
@@ -8480,6 +5531,7 @@ var require_jsverify = __commonJS({
 var require_lib = __commonJS({
   "../../node_modules/cross-fetch/node_modules/webidl-conversions/lib/index.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var conversions = {};
     module.exports = conversions;
     function sign(x) {
@@ -8634,9 +5686,10 @@ var require_lib = __commonJS({
 });
 
 // ../../node_modules/cross-fetch/node_modules/whatwg-url/lib/utils.js
-var require_utils2 = __commonJS({
+var require_utils = __commonJS({
   "../../node_modules/cross-fetch/node_modules/whatwg-url/lib/utils.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     module.exports.mixin = function mixin(target, source) {
       const keys = Object.getOwnPropertyNames(source);
       for (let i = 0; i < keys.length; ++i) {
@@ -8665,6 +5718,7 @@ var require_mappingTable = __commonJS({
 var require_tr46 = __commonJS({
   "../../node_modules/cross-fetch/node_modules/tr46/index.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var punycode = __require("punycode");
     var mappingTable = require_mappingTable();
     var PROCESSING_OPTIONS = {
@@ -8827,6 +5881,7 @@ var require_tr46 = __commonJS({
 var require_url_state_machine = __commonJS({
   "../../node_modules/cross-fetch/node_modules/whatwg-url/lib/url-state-machine.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var punycode = __require("punycode");
     var tr46 = require_tr46();
     var specialSchemes = {
@@ -8883,8 +5938,8 @@ var require_url_state_machine = __commonJS({
     function isSpecialScheme(scheme) {
       return specialSchemes[scheme] !== void 0;
     }
-    function isSpecial(url) {
-      return isSpecialScheme(url.scheme);
+    function isSpecial(url2) {
+      return isSpecialScheme(url2.scheme);
     }
     function defaultPort(scheme) {
       return specialSchemes[scheme];
@@ -9206,38 +6261,38 @@ var require_url_state_machine = __commonJS({
       }
       return host;
     }
-    function trimControlChars(url) {
-      return url.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, "");
+    function trimControlChars(url2) {
+      return url2.replace(/^[\u0000-\u001F\u0020]+|[\u0000-\u001F\u0020]+$/g, "");
     }
-    function trimTabAndNewline(url) {
-      return url.replace(/\u0009|\u000A|\u000D/g, "");
+    function trimTabAndNewline(url2) {
+      return url2.replace(/\u0009|\u000A|\u000D/g, "");
     }
-    function shortenPath(url) {
-      const path = url.path;
-      if (path.length === 0) {
+    function shortenPath(url2) {
+      const path2 = url2.path;
+      if (path2.length === 0) {
         return;
       }
-      if (url.scheme === "file" && path.length === 1 && isNormalizedWindowsDriveLetter(path[0])) {
+      if (url2.scheme === "file" && path2.length === 1 && isNormalizedWindowsDriveLetter(path2[0])) {
         return;
       }
-      path.pop();
+      path2.pop();
     }
-    function includesCredentials(url) {
-      return url.username !== "" || url.password !== "";
+    function includesCredentials(url2) {
+      return url2.username !== "" || url2.password !== "";
     }
-    function cannotHaveAUsernamePasswordPort(url) {
-      return url.host === null || url.host === "" || url.cannotBeABaseURL || url.scheme === "file";
+    function cannotHaveAUsernamePasswordPort(url2) {
+      return url2.host === null || url2.host === "" || url2.cannotBeABaseURL || url2.scheme === "file";
     }
     function isNormalizedWindowsDriveLetter(string) {
       return /^[A-Za-z]:$/.test(string);
     }
-    function URLStateMachine(input, base, encodingOverride, url, stateOverride) {
+    function URLStateMachine(input, base, encodingOverride, url2, stateOverride) {
       this.pointer = 0;
       this.input = input;
       this.base = base || null;
       this.encodingOverride = encodingOverride || "utf-8";
       this.stateOverride = stateOverride;
-      this.url = url;
+      this.url = url2;
       this.failure = false;
       this.parseError = false;
       if (!this.url) {
@@ -9790,36 +6845,36 @@ var require_url_state_machine = __commonJS({
       }
       return true;
     };
-    function serializeURL(url, excludeFragment) {
-      let output = url.scheme + ":";
-      if (url.host !== null) {
+    function serializeURL(url2, excludeFragment) {
+      let output = url2.scheme + ":";
+      if (url2.host !== null) {
         output += "//";
-        if (url.username !== "" || url.password !== "") {
-          output += url.username;
-          if (url.password !== "") {
-            output += ":" + url.password;
+        if (url2.username !== "" || url2.password !== "") {
+          output += url2.username;
+          if (url2.password !== "") {
+            output += ":" + url2.password;
           }
           output += "@";
         }
-        output += serializeHost(url.host);
-        if (url.port !== null) {
-          output += ":" + url.port;
+        output += serializeHost(url2.host);
+        if (url2.port !== null) {
+          output += ":" + url2.port;
         }
-      } else if (url.host === null && url.scheme === "file") {
+      } else if (url2.host === null && url2.scheme === "file") {
         output += "//";
       }
-      if (url.cannotBeABaseURL) {
-        output += url.path[0];
+      if (url2.cannotBeABaseURL) {
+        output += url2.path[0];
       } else {
-        for (const string of url.path) {
+        for (const string of url2.path) {
           output += "/" + string;
         }
       }
-      if (url.query !== null) {
-        output += "?" + url.query;
+      if (url2.query !== null) {
+        output += "?" + url2.query;
       }
-      if (!excludeFragment && url.fragment !== null) {
-        output += "#" + url.fragment;
+      if (!excludeFragment && url2.fragment !== null) {
+        output += "#" + url2.fragment;
       }
       return output;
     }
@@ -9832,11 +6887,11 @@ var require_url_state_machine = __commonJS({
       return result;
     }
     module.exports.serializeURL = serializeURL;
-    module.exports.serializeURLOrigin = function(url) {
-      switch (url.scheme) {
+    module.exports.serializeURLOrigin = function(url2) {
+      switch (url2.scheme) {
         case "blob":
           try {
-            return module.exports.serializeURLOrigin(module.exports.parseURL(url.path[0]));
+            return module.exports.serializeURLOrigin(module.exports.parseURL(url2.path[0]));
           } catch (e) {
             return "null";
           }
@@ -9847,9 +6902,9 @@ var require_url_state_machine = __commonJS({
         case "ws":
         case "wss":
           return serializeOrigin({
-            scheme: url.scheme,
-            host: url.host,
-            port: url.port
+            scheme: url2.scheme,
+            host: url2.host,
+            port: url2.port
           });
         case "file":
           return "file://";
@@ -9867,18 +6922,18 @@ var require_url_state_machine = __commonJS({
       }
       return usm.url;
     };
-    module.exports.setTheUsername = function(url, username) {
-      url.username = "";
+    module.exports.setTheUsername = function(url2, username) {
+      url2.username = "";
       const decoded = punycode.ucs2.decode(username);
       for (let i = 0; i < decoded.length; ++i) {
-        url.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
+        url2.username += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
       }
     };
-    module.exports.setThePassword = function(url, password) {
-      url.password = "";
+    module.exports.setThePassword = function(url2, password) {
+      url2.password = "";
       const decoded = punycode.ucs2.decode(password);
       for (let i = 0; i < decoded.length; ++i) {
-        url.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
+        url2.password += percentEncodeChar(decoded[i], isUserinfoPercentEncode);
       }
     };
     module.exports.serializeHost = serializeHost;
@@ -9899,10 +6954,11 @@ var require_url_state_machine = __commonJS({
 var require_URL_impl = __commonJS({
   "../../node_modules/cross-fetch/node_modules/whatwg-url/lib/URL-impl.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var usm = require_url_state_machine();
     exports.implementation = class URLImpl {
       constructor(constructorArgs) {
-        const url = constructorArgs[0];
+        const url2 = constructorArgs[0];
         const base = constructorArgs[1];
         let parsedBase = null;
         if (base !== void 0) {
@@ -9911,7 +6967,7 @@ var require_URL_impl = __commonJS({
             throw new TypeError("Invalid base URL");
           }
         }
-        const parsedURL = usm.basicURLParse(url, { baseURL: parsedBase });
+        const parsedURL = usm.basicURLParse(url2, { baseURL: parsedBase });
         if (parsedURL === "failure") {
           throw new TypeError("Invalid URL");
         }
@@ -9955,14 +7011,14 @@ var require_URL_impl = __commonJS({
         usm.setThePassword(this._url, v);
       }
       get host() {
-        const url = this._url;
-        if (url.host === null) {
+        const url2 = this._url;
+        if (url2.host === null) {
           return "";
         }
-        if (url.port === null) {
-          return usm.serializeHost(url.host);
+        if (url2.port === null) {
+          return usm.serializeHost(url2.host);
         }
-        return usm.serializeHost(url.host) + ":" + usm.serializeInteger(url.port);
+        return usm.serializeHost(url2.host) + ":" + usm.serializeInteger(url2.port);
       }
       set host(v) {
         if (this._url.cannotBeABaseURL) {
@@ -10021,14 +7077,14 @@ var require_URL_impl = __commonJS({
         return "?" + this._url.query;
       }
       set search(v) {
-        const url = this._url;
+        const url2 = this._url;
         if (v === "") {
-          url.query = null;
+          url2.query = null;
           return;
         }
         const input = v[0] === "?" ? v.substring(1) : v;
-        url.query = "";
-        usm.basicURLParse(input, { url, stateOverride: "query" });
+        url2.query = "";
+        usm.basicURLParse(input, { url: url2, stateOverride: "query" });
       }
       get hash() {
         if (this._url.fragment === null || this._url.fragment === "") {
@@ -10056,11 +7112,12 @@ var require_URL_impl = __commonJS({
 var require_URL = __commonJS({
   "../../node_modules/cross-fetch/node_modules/whatwg-url/lib/URL.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var conversions = require_lib();
-    var utils = require_utils2();
+    var utils = require_utils();
     var Impl = require_URL_impl();
     var impl = utils.implSymbol;
-    function URL2(url) {
+    function URL2(url2) {
       if (!this || this[impl] || !(this instanceof URL2)) {
         throw new TypeError("Failed to construct 'URL': Please use the 'new' operator, this DOM object constructor cannot be called as a function.");
       }
@@ -10239,6 +7296,7 @@ var require_URL = __commonJS({
 var require_public_api = __commonJS({
   "../../node_modules/cross-fetch/node_modules/whatwg-url/lib/public-api.js"(exports) {
     "use strict";
+    init_cjs_shim();
     exports.URL = require_URL().interface;
     exports.serializeURL = require_url_state_machine().serializeURL;
     exports.serializeURLOrigin = require_url_state_machine().serializeURLOrigin;
@@ -10255,6 +7313,7 @@ var require_public_api = __commonJS({
 var require_safer = __commonJS({
   "../../node_modules/safer-buffer/safer.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var buffer = __require("buffer");
     var Buffer2 = buffer.Buffer;
     var safer = {};
@@ -10327,6 +7386,7 @@ var require_safer = __commonJS({
 var require_bom_handling = __commonJS({
   "../../node_modules/iconv-lite/lib/bom-handling.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var BOMChar = "\uFEFF";
     exports.PrependBOM = PrependBOMWrapper;
     function PrependBOMWrapper(encoder, options) {
@@ -10371,6 +7431,7 @@ var require_bom_handling = __commonJS({
 var require_internal = __commonJS({
   "../../node_modules/iconv-lite/encodings/internal.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     module.exports = {
       // Encodings
@@ -10515,6 +7576,7 @@ var require_internal = __commonJS({
 var require_utf16 = __commonJS({
   "../../node_modules/iconv-lite/encodings/utf16.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     exports.utf16be = Utf16BECodec;
     function Utf16BECodec() {
@@ -10633,6 +7695,7 @@ var require_utf16 = __commonJS({
 var require_utf7 = __commonJS({
   "../../node_modules/iconv-lite/encodings/utf7.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     exports.utf7 = Utf7Codec;
     exports.unicode11utf7 = "utf7";
@@ -10834,6 +7897,7 @@ var require_utf7 = __commonJS({
 var require_sbcs_codec = __commonJS({
   "../../node_modules/iconv-lite/encodings/sbcs-codec.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     exports._sbcs = SBCSCodec;
     function SBCSCodec(codecOptions, iconv) {
@@ -10890,6 +7954,7 @@ var require_sbcs_codec = __commonJS({
 var require_sbcs_data = __commonJS({
   "../../node_modules/iconv-lite/encodings/sbcs-data.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     module.exports = {
       // Not supported by iconv, not sure why.
       "10029": "maccenteuro",
@@ -11039,6 +8104,7 @@ var require_sbcs_data = __commonJS({
 var require_sbcs_data_generated = __commonJS({
   "../../node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     module.exports = {
       "437": "cp437",
       "737": "cp737",
@@ -11494,6 +8560,7 @@ var require_sbcs_data_generated = __commonJS({
 var require_dbcs_codec = __commonJS({
   "../../node_modules/iconv-lite/encodings/dbcs-codec.js"(exports) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     exports._dbcs = DBCSCodec;
     var UNASSIGNED = -1;
@@ -13126,6 +10193,7 @@ var require_big5_added = __commonJS({
 var require_dbcs_data = __commonJS({
   "../../node_modules/iconv-lite/encodings/dbcs-data.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     module.exports = {
       // == Japanese/ShiftJIS ====================================================
       // All japanese encodings are based on JIS X set of standards:
@@ -13301,6 +10369,7 @@ var require_dbcs_data = __commonJS({
 var require_encodings = __commonJS({
   "../../node_modules/iconv-lite/encodings/index.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var modules = [
       require_internal(),
       require_utf16(),
@@ -13327,6 +10396,7 @@ var require_encodings = __commonJS({
 var require_streams = __commonJS({
   "../../node_modules/iconv-lite/lib/streams.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = __require("buffer").Buffer;
     var Transform = __require("stream").Transform;
     module.exports = function(iconv) {
@@ -13432,6 +10502,7 @@ var require_streams = __commonJS({
 var require_extend_node = __commonJS({
   "../../node_modules/iconv-lite/lib/extend-node.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = __require("buffer").Buffer;
     module.exports = function(iconv) {
       var original = void 0;
@@ -13601,6 +10672,7 @@ var require_extend_node = __commonJS({
 var require_lib2 = __commonJS({
   "../../node_modules/iconv-lite/lib/index.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var Buffer2 = require_safer().Buffer;
     var bomHandling = require_bom_handling();
     var iconv = module.exports;
@@ -13704,6 +10776,7 @@ var require_lib2 = __commonJS({
 var require_iconv_loader = __commonJS({
   "../../node_modules/encoding/lib/iconv-loader.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var iconv_package;
     var Iconv;
     try {
@@ -13719,6 +10792,7 @@ var require_iconv_loader = __commonJS({
 var require_encoding = __commonJS({
   "../../node_modules/encoding/lib/encoding.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     var iconvLite = require_lib2();
     var Iconv = require_iconv_loader();
     module.exports.convert = convert;
@@ -13786,6 +10860,7 @@ var require_encoding = __commonJS({
 var require_lib3 = __commonJS({
   "../../node_modules/cross-fetch/node_modules/node-fetch/lib/index.js"(exports, module) {
     "use strict";
+    init_cjs_shim();
     Object.defineProperty(exports, "__esModule", { value: true });
     function _interopDefault(ex) {
       return ex && typeof ex === "object" && "default" in ex ? ex["default"] : ex;
@@ -14781,13 +11856,13 @@ var require_lib3 = __commonJS({
       const dest = new URL$1(destination).protocol;
       return orig === dest;
     };
-    function fetch2(url, opts) {
+    function fetch2(url2, opts) {
       if (!fetch2.Promise) {
         throw new Error("native promise missing, set fetch.Promise to your favorite alternative");
       }
       Body.Promise = fetch2.Promise;
       return new fetch2.Promise(function(resolve, reject) {
-        const request = new Request(url, opts);
+        const request = new Request(url2, opts);
         const options = getNodeRequestOptions(request);
         const send = (options.protocol === "https:" ? https : http).request;
         const signal = request.signal;
@@ -15032,13 +12107,14 @@ var require_lib3 = __commonJS({
 // ../../node_modules/cross-fetch/dist/node-ponyfill.js
 var require_node_ponyfill = __commonJS({
   "../../node_modules/cross-fetch/dist/node-ponyfill.js"(exports, module) {
+    init_cjs_shim();
     var nodeFetch = require_lib3();
     var realFetch = nodeFetch.default || nodeFetch;
-    var fetch2 = function(url, options) {
-      if (/^\/\//.test(url)) {
-        url = "https:" + url;
+    var fetch2 = function(url2, options) {
+      if (/^\/\//.test(url2)) {
+        url2 = "https:" + url2;
       }
-      return realFetch.call(this, url, options);
+      return realFetch.call(this, url2, options);
     };
     fetch2.ponyfill = true;
     module.exports = exports = fetch2;
@@ -15050,8 +12126,15 @@ var require_node_ponyfill = __commonJS({
   }
 });
 
+// src/index.ts
+init_cjs_shim();
+
+// ../../magda-typescript-common/dist/test/arbitraries.js
+init_cjs_shim();
+
 // ../../node_modules/@magda/esm-utils/dist/esmUtils.js
-import { createRequire } from "module";
+init_cjs_shim();
+import { createRequire as createRequire2 } from "module";
 function callsites() {
   const _prepareStackTrace = Error.prepareStackTrace;
   try {
@@ -15087,11 +12170,15 @@ function callerpath({ depth = 0 } = {}) {
   return callsite && callsite.getFileName();
 }
 function require2(id) {
-  const requireFrom = createRequire(callerpath({ depth: 1 }));
+  const requireFrom = createRequire2(callerpath({ depth: 1 }));
   return requireFrom(id);
 }
 
+// ../../node_modules/uuid/dist/esm-node/index.js
+init_cjs_shim();
+
 // ../../node_modules/uuid/dist/esm-node/rng.js
+init_cjs_shim();
 import crypto from "crypto";
 var rnds8 = new Uint8Array(16);
 function rng() {
@@ -15099,6 +12186,7 @@ function rng() {
 }
 
 // ../../node_modules/uuid/dist/esm-node/bytesToUuid.js
+init_cjs_shim();
 var byteToHex = [];
 for (let i = 0; i < 256; ++i) {
   byteToHex.push((i + 256).toString(16).substr(1));
@@ -15110,6 +12198,7 @@ function bytesToUuid(buf, offset_) {
 var bytesToUuid_default = bytesToUuid;
 
 // ../../node_modules/uuid/dist/esm-node/v4.js
+init_cjs_shim();
 function v4(options, buf, offset) {
   options = options || {};
   const rnds = options.random || (options.rng || rng)();
@@ -15128,7 +12217,7 @@ var v4_default = v4;
 
 // ../../magda-typescript-common/dist/test/arbitraries.js
 var import_lodash = __toESM(require_lodash(), 1);
-var import_jsverify = __toESM(require_jsverify(), 1);
+import jsc from "jsverify";
 var { curried2 } = require2("jsverify/lib/utils");
 var lazyseq = require2("lazy-seq");
 function fromCode(code) {
@@ -15137,46 +12226,46 @@ function fromCode(code) {
 function toCode(c) {
   return c.charCodeAt(0);
 }
-var charArb = import_jsverify.default.integer(32, 255).smap(fromCode, toCode);
-var stringArb = import_jsverify.default.array(charArb).smap((chars) => chars.join(""), (string) => string.split(""));
-var lowerCaseAlphaCharArb = import_jsverify.default.integer(97, 122).smap(fromCode, toCode);
-var numArb = import_jsverify.default.integer(48, 57).smap(fromCode, toCode);
-var lcAlphaNumCharArb = import_jsverify.default.oneof([numArb, lowerCaseAlphaCharArb]);
-var lcAlphaNumStringArb = import_jsverify.default.array(lcAlphaNumCharArb).smap((arr) => arr.join(""), (string) => string.split(""));
-var lcAlphaNumStringArbNe = import_jsverify.default.nearray(lcAlphaNumCharArb).smap((arr) => arr.join(""), (string) => string.split(""));
-var lcAlphaStringArb = import_jsverify.default.array(lowerCaseAlphaCharArb).smap((chars) => chars.join(""), (string) => string.split(""));
-var lcAlphaStringArbNe = import_jsverify.default.nearray(lowerCaseAlphaCharArb).smap((chars) => chars.join(""), (string) => string.split(""));
-var peopleNameArb = import_jsverify.default.tuple([lcAlphaStringArbNe, lcAlphaStringArbNe]).smap((strArr) => strArr.join(" "), (string) => string.split(" "));
-var uuidArb = import_jsverify.default.bless({
-  generator: import_jsverify.default.generator.bless((x) => v4_default()),
-  shrink: import_jsverify.default.shrink.bless((x) => []),
+var charArb = jsc.integer(32, 255).smap(fromCode, toCode);
+var stringArb = jsc.array(charArb).smap((chars) => chars.join(""), (string) => string.split(""));
+var lowerCaseAlphaCharArb = jsc.integer(97, 122).smap(fromCode, toCode);
+var numArb = jsc.integer(48, 57).smap(fromCode, toCode);
+var lcAlphaNumCharArb = jsc.oneof([numArb, lowerCaseAlphaCharArb]);
+var lcAlphaNumStringArb = jsc.array(lcAlphaNumCharArb).smap((arr) => arr.join(""), (string) => string.split(""));
+var lcAlphaNumStringArbNe = jsc.nearray(lcAlphaNumCharArb).smap((arr) => arr.join(""), (string) => string.split(""));
+var lcAlphaStringArb = jsc.array(lowerCaseAlphaCharArb).smap((chars) => chars.join(""), (string) => string.split(""));
+var lcAlphaStringArbNe = jsc.nearray(lowerCaseAlphaCharArb).smap((chars) => chars.join(""), (string) => string.split(""));
+var peopleNameArb = jsc.tuple([lcAlphaStringArbNe, lcAlphaStringArbNe]).smap((strArr) => strArr.join(" "), (string) => string.split(" "));
+var uuidArb = jsc.bless({
+  generator: jsc.generator.bless((x) => v4_default()),
+  shrink: jsc.shrink.bless((x) => []),
   show: (x) => x
 });
-var intArb = import_jsverify.default.integer(48, 57);
-var recordArb = import_jsverify.default.record({
+var intArb = jsc.integer(48, 57);
+var recordArb = jsc.record({
   id: uuidArb,
   name: stringArb,
-  aspects: import_jsverify.default.suchthat(import_jsverify.default.array(import_jsverify.default.json), (arr) => arr.length <= 10),
-  sourceTag: import_jsverify.default.constant(void 0),
+  aspects: jsc.suchthat(jsc.array(jsc.json), (arr) => arr.length <= 10),
+  sourceTag: jsc.constant(void 0),
   tenantId: intArb
 });
-var specificRecordArb = (aspectArbs) => import_jsverify.default.record({
+var specificRecordArb = (aspectArbs) => jsc.record({
   id: uuidArb,
   name: stringArb,
-  aspects: import_jsverify.default.record(aspectArbs),
-  sourceTag: import_jsverify.default.constant(void 0),
+  aspects: jsc.record(aspectArbs),
+  sourceTag: jsc.constant(void 0),
   tenantId: intArb
 });
-var defaultSchemeArb = import_jsverify.default.oneof([
-  import_jsverify.default.constant("http"),
-  import_jsverify.default.constant("https"),
-  import_jsverify.default.constant("ftp"),
+var defaultSchemeArb = jsc.oneof([
+  jsc.constant("http"),
+  jsc.constant("https"),
+  jsc.constant("ftp"),
   lcAlphaNumStringArbNe
 ]);
 function shrinkArrayWithMinimumSize(size) {
   function shrinkArrayImpl(...args) {
     const shrink = args[0];
-    const result = import_jsverify.default.shrink.bless(function(arr) {
+    const result = jsc.shrink.bless(function(arr) {
       if (arr.length <= size) {
         return lazyseq.nil;
       } else {
@@ -15197,12 +12286,12 @@ function unSeq(maybeArray) {
   return maybeArray.toArray ? maybeArray.toArray() : maybeArray;
 }
 function arbFlatMap(arb, arbForward, backwards, show = (u) => JSON.stringify(u)) {
-  const x = import_jsverify.default.bless({
+  const x = jsc.bless({
     generator: arb.generator.flatmap((t) => {
       return arbForward(t).generator;
     }),
     show,
-    shrink: import_jsverify.default.shrink.bless((u) => {
+    shrink: jsc.shrink.bless((u) => {
       const t = backwards(u);
       if (import_lodash.default.isUndefined(t)) {
         return [];
@@ -15210,7 +12299,7 @@ function arbFlatMap(arb, arbForward, backwards, show = (u) => JSON.stringify(u))
       const ts = unSeq(arb.shrink(t));
       const us = (0, import_lodash.default)(ts).flatMap((thisT) => {
         const newArb = arbForward(thisT);
-        const newU = import_jsverify.default.sampler(newArb, ts.length)(1)[0];
+        const newU = jsc.sampler(newArb, ts.length)(1)[0];
         return import_lodash.default.take(unSeq(newArb.shrink(newU)), 3);
       }).value();
       return us;
@@ -15224,7 +12313,7 @@ function arbFlatMap(arb, arbForward, backwards, show = (u) => JSON.stringify(u))
   };
 }
 function generateArrayOfSize(arrSize, gen) {
-  var result = import_jsverify.default.generator.bless(function(size) {
+  var result = jsc.generator.bless(function(size) {
     var arr = new Array(arrSize);
     for (var i = 0; i < arrSize; i++) {
       arr[i] = gen(size);
@@ -15234,50 +12323,50 @@ function generateArrayOfSize(arrSize, gen) {
   return result;
 }
 function arrayOfSizeArb(size, arb) {
-  return import_jsverify.default.bless({
+  return jsc.bless({
     generator: generateArrayOfSize(size, arb.generator),
     shrink: shrinkArrayWithMinimumSize(size)(arb.shrink),
     show: (x) => x.toString()
   });
 }
-var urlPartsArb = (options) => import_jsverify.default.record({
+var urlPartsArb = (options) => jsc.record({
   scheme: options.schemeArb,
-  host: import_jsverify.default.suchthat(options.hostArb, (string) => !string.startsWith("ftp")),
-  port: import_jsverify.default.oneof([
-    import_jsverify.default.integer(1, 65e3),
-    import_jsverify.default.constant(80),
-    import_jsverify.default.constant(21)
+  host: jsc.suchthat(options.hostArb, (string) => !string.startsWith("ftp")),
+  port: jsc.oneof([
+    jsc.integer(1, 65e3),
+    jsc.constant(80),
+    jsc.constant(21)
   ]),
-  path: import_jsverify.default.array(lcAlphaNumStringArbNe)
+  path: jsc.array(lcAlphaNumStringArbNe)
 });
 var distUrlArb = ({ schemeArb = defaultSchemeArb, hostArb = lcAlphaNumStringArbNe } = {}) => urlPartsArb({ schemeArb, hostArb }).smap((urlParts) => {
   const port = urlParts.scheme === "http" && urlParts.port === 80 || urlParts.scheme === "ftp" && urlParts.port === 21 ? "" : ":" + urlParts.port;
   return `${urlParts.scheme}://${urlParts.host}.com${port}/${(urlParts.path || []).join("/")}`;
-}, (url) => {
-  const splitAfterScheme = url.split("://");
+}, (url2) => {
+  const splitAfterScheme = url2.split("://");
   const scheme = splitAfterScheme[0];
   const splitOnDotCom = splitAfterScheme[1].split(/\.com:?/);
   const host = splitOnDotCom[0];
   const pathSegments = splitOnDotCom[1].split("/");
   const port = parseInt(pathSegments[0]);
-  const path = pathSegments.slice(1);
-  return { scheme, host, port, path };
+  const path2 = pathSegments.slice(1);
+  return { scheme, host, port, path: path2 };
 });
-var distStringsArb = ({ url = import_jsverify.default.oneof([distUrlArb(), import_jsverify.default.constant(void 0)]), license = stringArb, format = stringArb }) => import_jsverify.default.record({
-  downloadURL: url,
-  accessURL: url,
+var distStringsArb = ({ url: url2 = jsc.oneof([distUrlArb(), jsc.constant(void 0)]), license = stringArb, format = stringArb }) => jsc.record({
+  downloadURL: url2,
+  accessURL: url2,
   license,
   format
 });
-var sourceLinkArb = ({ status = import_jsverify.default.constant("active") }) => import_jsverify.default.record({
+var sourceLinkArb = ({ status = jsc.constant("active") }) => jsc.record({
   status
 });
-var datasetFormatArb = ({ format = stringArb }) => import_jsverify.default.record({
+var datasetFormatArb = ({ format = stringArb }) => jsc.record({
   format
 });
 var recordArbWithDistArbs = (distStringsOverrides = {}, sourceLinkOverrides = {}, datasetFormatOverrides = {}) => specificRecordArb({
-  "dataset-distributions": import_jsverify.default.record({
-    distributions: import_jsverify.default.array(specificRecordArb({
+  "dataset-distributions": jsc.record({
+    distributions: jsc.array(specificRecordArb({
       "dcat-distribution-strings": distStringsArb(distStringsOverrides),
       "dataset-format": datasetFormatArb(datasetFormatOverrides),
       "source-link-status": sourceLinkArb(sourceLinkOverrides)
@@ -15285,16 +12374,16 @@ var recordArbWithDistArbs = (distStringsOverrides = {}, sourceLinkOverrides = {}
   })
 });
 var recordArbWithDists = (dists) => specificRecordArb({
-  "dataset-distributions": import_jsverify.default.record({
-    distributions: import_jsverify.default.tuple(dists.map((dist) => specificRecordArb({
-      "dcat-distribution-strings": import_jsverify.default.constant(dist)
+  "dataset-distributions": jsc.record({
+    distributions: jsc.tuple(dists.map((dist) => specificRecordArb({
+      "dcat-distribution-strings": jsc.constant(dist)
     })))
   })
 });
 function someOf(array) {
-  return import_jsverify.default.record({
-    length: import_jsverify.default.integer(0, array.length),
-    start: import_jsverify.default.integer(0, array.length - 1)
+  return jsc.record({
+    length: jsc.integer(0, array.length),
+    start: jsc.integer(0, array.length - 1)
   }).smap(({ length, start }) => (0, import_lodash.default)(array).drop(start).take(length).value(), (newArray) => {
     const start = import_lodash.default.indexOf(array, newArray[0]);
     const length = newArray.length - start;
@@ -15306,8 +12395,8 @@ function fuzzStringArb(string, fuzzArb = stringArb) {
   const aroundArbs = arrayOfSizeArb(words.length + 1, fuzzArb);
   return arbFlatMap(aroundArbs, (around) => {
     const string2 = (0, import_lodash.default)(around).zip(words).flatten().join("");
-    const caseArb = arrayOfSizeArb(string2.length, import_jsverify.default.bool);
-    return import_jsverify.default.record({ string: import_jsverify.default.constant(string2), cases: caseArb });
+    const caseArb = arrayOfSizeArb(string2.length, jsc.bool);
+    return jsc.record({ string: jsc.constant(string2), cases: caseArb });
   }, ({ string: string2, cases }) => {
     const wordsRegex = new RegExp(words.join("|"));
     return string2.split(wordsRegex);
@@ -15325,9 +12414,10 @@ function fuzzStringArb(string, fuzzArb = stringArb) {
 function fuzzStringArbResult(stringArb2, fuzzArb) {
   return arbFlatMap(stringArb2, (string) => fuzzStringArb(string, fuzzArb), (fuzzedString) => void 0);
 }
-var dateStringArb = import_jsverify.default.datetime.smap((date) => date.toString(), (string) => new Date(Date.parse(string)));
+var dateStringArb = jsc.datetime.smap((date) => date.toString(), (string) => new Date(Date.parse(string)));
 
 // ../../magda-typescript-common/dist/generated/registry/api.js
+init_cjs_shim();
 var import_cross_fetch = __toESM(require_node_ponyfill(), 1);
 var Record = class {
   /**