return function (engine, locale) {
     const n = integer(min, max)(engine);
     return [...new Array(n).keys()].map(() => {
         const chosenArb = arb ? arb : recursive(array, any, 2);
         return chosenArb.makeGenerator()(engine, locale);
     });
 };

 integer(min: number | undefined, max: number | undefined): number {
     if (!min)
         min = 1;
     if (!max)
         max = min;
     if (max < min)
         throw new Error('minmax');
     return randomjs.integer(min, max)(this.engine);
 }

 function rec(n: number): Arbitrary<V, RecursiveGenOpts<V, O>> {
     const chance = integer(0, 3)(engine);
     if (n <= 0 || chance === 0) {
         return n === depth ? combinator(arb) : arb;
     }
     else {
         return combinator(rec(n - 1));
     }
 };

 export function shuffle<T>(array: Array<T>) {
     let n = array.length;
     for (let i = n - 1; i > 0; i=i-1) {
         let j = rand.integer(0, i);
         let tmp = array[i];
         array[i] = array[j];
         array[j] = tmp;
     }
 }

function mutateNode(keys: string[], random: Random, entity: Entity): Entity {
  const willMutate = random.bool(MUTATE_PERCENTAGE);

  if (!willMutate) {
    return entity;
  }

  const mutationId = random.integer(MIN_SEED, MAX_SEED);
  const mutation = chooseMutation(keys, mutationId, entity);

  return applyMutation(entity, mutation);
}

function generateEntities(
  random: Random,
  generationSize: number,
  keys: string[]
): Entity[] {
  const entities = [];

  while (entities.length < generationSize) {
    entities.push(generateEntity(random.integer(MIN_SEED, MAX_SEED), keys));
  }

  return entities;
}

 return function (engine, locale) {
     function pick(n: number, [[k, x], ...xs]): any {
         return (n <= k) ? x : pick(n - k, xs);
     }
     const total = sum(pool.map(e => e[0]));
     const head = integer(1, total)(engine);
     const result = pick(head, pool);
     if (result instanceof Arbitrary) {
         return result.makeGenerator()(engine, locale);
     }
     else {
         return result;
     };
 };

 gen: (opts: { min: number }) => (engine) => integer(opts.min, 2)(engine),

 randexp.randInt = (from: number, to: number) => {
     return integer(from, to)(engine);
 }

export function integer(min: number, max: number): number {
    return Random.integer(min, max)(engine);
}