effect 3.11.5 → 3.11.7

package/dist/esm/Arbitrary.js

@@ -26,39 +26,134 @@ export const makeLazy = schema => go(schema.ast, {
  */
 export const make = schema => makeLazy(schema)(FastCheck);
 const getArbitraryAnnotation = /*#__PURE__*/AST.getAnnotation(AST.ArbitraryAnnotationId);
-const getRefinementFromArbitrary = (ast, ctx, path) => {
-  const constraints = combineConstraints(ctx.constraints, getConstraints(ast));
-  return go(ast.from, constraints ? {
-    ...ctx,
-    constraints
-  } : ctx, path);
+/**
+ * Represents an arbitrary with optional filters.
+ */
+class Succeed {
+  lazyArbitrary;
+  filters;
+  _tag = "Succeed";
+  constructor(lazyArbitrary, filters = []) {
+    this.lazyArbitrary = lazyArbitrary;
+    this.filters = filters;
+  }
+  toLazyArbitrary() {
+    return fc => {
+      let out = this.lazyArbitrary(fc);
+      for (const f of this.filters) {
+        out = out.filter(f);
+      }
+      return out;
+    };
+  }
+}
+/**
+ * Represents a deferred arbitrary value generator with optional filters.
+ */
+class Deferred {
+  config;
+  filters;
+  _tag = "Deferred";
+  constructor(config, filters = []) {
+    this.config = config;
+    this.filters = filters;
+  }
+  toLazyArbitrary(ctx, path) {
+    const config = this.config;
+    switch (config._tag) {
+      case "StringConstraints":
+        {
+          const pattern = config.pattern;
+          return pattern !== undefined ? fc => fc.stringMatching(new RegExp(pattern)) : fc => fc.string(config.constraints);
+        }
+      case "NumberConstraints":
+        {
+          return config.isInteger ? fc => fc.integer(config.constraints) : fc => fc.float(config.constraints);
+        }
+      case "BigIntConstraints":
+        return fc => fc.bigInt(config.constraints);
+      case "ArrayConstraints":
+        return goTupleType(config.ast, ctx, path, config.constraints);
+    }
+  }
+}
+/** @internal */
+export const makeStringConstraints = options => {
+  const out = {
+    _tag: "StringConstraints",
+    constraints: {}
+  };
+  if (Predicate.isNumber(options.minLength)) {
+    out.constraints.minLength = options.minLength;
+  }
+  if (Predicate.isNumber(options.maxLength)) {
+    out.constraints.maxLength = options.maxLength;
+  }
+  if (Predicate.isString(options.pattern)) {
+    out.pattern = options.pattern;
+  }
+  return out;
 };
-const getSuspendedContext = (ctx, ast) => {
-  if (ctx.depthIdentifier !== undefined) {
-    return ctx;
+/** @internal */
+export const makeNumberConstraints = options => {
+  const out = {
+    _tag: "NumberConstraints",
+    constraints: {},
+    isInteger: options.isInteger ?? false
+  };
+  if (Predicate.isNumber(options.min)) {
+    out.constraints.min = Math.fround(options.min);
   }
-  const depthIdentifier = AST.getIdentifierAnnotation(ast).pipe(Option.orElse(() => AST.getIdentifierAnnotation(ast.f())), Option.getOrElse(() => "SuspendDefaultDepthIdentifier"));
-  return {
-    ...ctx,
-    depthIdentifier
+  if (Predicate.isBoolean(options.minExcluded)) {
+    out.constraints.minExcluded = options.minExcluded;
+  }
+  if (Predicate.isNumber(options.max)) {
+    out.constraints.max = Math.fround(options.max);
+  }
+  if (Predicate.isBoolean(options.maxExcluded)) {
+    out.constraints.maxExcluded = options.maxExcluded;
+  }
+  if (Predicate.isBoolean(options.noNaN)) {
+    out.constraints.noNaN = options.noNaN;
+  }
+  if (Predicate.isBoolean(options.noDefaultInfinity)) {
+    out.constraints.noDefaultInfinity = options.noDefaultInfinity;
+  }
+  return out;
+};
+/** @internal */
+export const makeBigIntConstraints = options => {
+  const out = {
+    _tag: "BigIntConstraints",
+    constraints: {}
   };
+  if (Predicate.isBigInt(options.min)) {
+    out.constraints.min = options.min;
+  }
+  if (Predicate.isBigInt(options.max)) {
+    out.constraints.max = options.max;
+  }
+  return out;
 };
-const getSuspendedArray = (fc, depthIdentifier, maxDepth, item, constraints) => {
-  let minLength = 1;
-  let maxLength = 2;
-  if (constraints && constraints.minLength !== undefined && constraints.minLength > minLength) {
-    minLength = constraints.minLength;
-    if (minLength > maxLength) {
-      maxLength = minLength;
-    }
+/** @internal */
+export const makeArrayConstraints = options => {
+  const out = {
+    _tag: "ArrayConstraints",
+    constraints: {}
+  };
+  if (Predicate.isNumber(options.minLength)) {
+    out.constraints.minLength = options.minLength;
   }
-  return fc.oneof({
-    maxDepth,
-    depthIdentifier
-  }, fc.constant([]), fc.array(item, {
-    minLength,
-    maxLength
-  }));
+  if (Predicate.isNumber(options.maxLength)) {
+    out.constraints.maxLength = options.maxLength;
+  }
+  return out;
+};
+const makeArrayConfig = (options, ast) => {
+  return {
+    ast,
+    ...makeArrayConstraints(options)
+  };
 };
 const go = (ast, ctx, path) => {
   const hook = getArbitraryAnnotation(ast);
@@ -67,152 +162,120 @@ const go = (ast, ctx, path) => {
       case "Declaration":
         return hook.value(...ast.typeParameters.map(p => go(p, ctx, path)), ctx);
       case "Refinement":
-        return hook.value(getRefinementFromArbitrary(ast, ctx, path), ctx);
+        {
+          const op = toOp(ast, ctx, path);
+          ctx = op._tag === "Deferred" ? {
+            ...ctx,
+            constraints: op.config
+          } : ctx;
+          const from = go(ast.from, ctx, path);
+          return new Succeed(hook.value(from, ctx), op.filters).toLazyArbitrary();
+        }
       default:
         return hook.value(ctx);
     }
   }
+  if (AST.isDeclaration(ast)) {
+    throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(path, ast));
+  }
+  const op = toOp(ast, ctx, path);
+  switch (op._tag) {
+    case "Succeed":
+      return op.toLazyArbitrary();
+    case "Deferred":
+      return new Succeed(op.toLazyArbitrary(ctx, path), op.filters).toLazyArbitrary();
+  }
+};
+const constStringConstraints = /*#__PURE__*/makeStringConstraints({});
+const constNumberConstraints = /*#__PURE__*/makeNumberConstraints({});
+const constBigIntConstraints = /*#__PURE__*/makeBigIntConstraints({});
+/** @internal */
+export const toOp = (ast, ctx, path) => {
   switch (ast._tag) {
     case "Declaration":
-      {
-        throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(path, ast));
-      }
+      return new Succeed(go(ast, ctx, path));
     case "Literal":
-      return fc => fc.constant(ast.literal);
+      return new Succeed(fc => fc.constant(ast.literal));
     case "UniqueSymbol":
-      return fc => fc.constant(ast.symbol);
+      return new Succeed(fc => fc.constant(ast.symbol));
     case "UndefinedKeyword":
-      return fc => fc.constant(undefined);
+      return new Succeed(fc => fc.constant(undefined));
     case "NeverKeyword":
-      return () => {
-        throw new Error(errors_.getArbitraryUnsupportedErrorMessage(path, ast));
-      };
+      throw new Error(errors_.getArbitraryMissingAnnotationErrorMessage(path, ast));
+    case "VoidKeyword":
     case "UnknownKeyword":
     case "AnyKeyword":
-    case "VoidKeyword":
-      return fc => fc.anything();
+      return new Succeed(fc => fc.anything());
     case "StringKeyword":
-      return fc => {
-        if (ctx.constraints) {
-          switch (ctx.constraints._tag) {
-            case "StringConstraints":
-              return fc.string(ctx.constraints.constraints);
-          }
-        }
-        return fc.string();
-      };
+      return new Deferred(constStringConstraints);
     case "NumberKeyword":
-      return fc => {
-        if (ctx.constraints) {
-          switch (ctx.constraints._tag) {
-            case "NumberConstraints":
-              return fc.float(ctx.constraints.constraints);
-            case "IntegerConstraints":
-              return fc.integer(ctx.constraints.constraints);
-          }
-        }
-        return fc.float();
-      };
+      return new Deferred(constNumberConstraints);
     case "BooleanKeyword":
-      return fc => fc.boolean();
+      return new Succeed(fc => fc.boolean());
     case "BigIntKeyword":
-      return fc => {
-        if (ctx.constraints) {
-          switch (ctx.constraints._tag) {
-            case "BigIntConstraints":
-              return fc.bigInt(ctx.constraints.constraints);
-          }
-        }
-        return fc.bigInt();
-      };
+      return new Deferred(constBigIntConstraints);
     case "SymbolKeyword":
-      return fc => fc.string().map(s => Symbol.for(s));
+      return new Succeed(fc => fc.string().map(s => Symbol.for(s)));
     case "ObjectKeyword":
-      return fc => fc.oneof(fc.object(), fc.array(fc.anything()));
-    case "TemplateLiteral":
+      return new Succeed(fc => fc.oneof(fc.object(), fc.array(fc.anything())));
+    case "Enums":
       {
-        return fc => {
-          const string = fc.string({
-            maxLength: 5
-          });
-          const number = fc.float({
-            noDefaultInfinity: true
-          }).filter(n => !Number.isNaN(n));
-          const components = ast.head !== "" ? [fc.constant(ast.head)] : [];
-          const addArb = ast => {
-            switch (ast._tag) {
-              case "StringKeyword":
-                return components.push(string);
-              case "NumberKeyword":
-                return components.push(number);
-              case "Literal":
-                return components.push(fc.constant(String(ast.literal)));
-              case "Union":
-                return ast.types.forEach(addArb);
-            }
-          };
-          ast.spans.forEach(span => {
-            addArb(span.type);
-            if (span.literal !== "") {
-              components.push(fc.constant(span.literal));
-            }
-          });
-          return fc.tuple(...components).map(spans => spans.join(""));
-        };
+        if (ast.enums.length === 0) {
+          throw new Error(errors_.getArbitraryEmptyEnumErrorMessage(path));
+        }
+        return new Succeed(fc => fc.oneof(...ast.enums.map(([_, value]) => fc.constant(value))));
       }
-    case "TupleType":
-      {
-        const elements = [];
-        let hasOptionals = false;
-        let i = 0;
-        for (const element of ast.elements) {
-          elements.push(go(element.type, ctx, path.concat(i++)));
-          if (element.isOptional) {
-            hasOptionals = true;
+    case "TemplateLiteral":
+      return new Succeed(fc => {
+        const string = fc.string({
+          maxLength: 5
+        });
+        const number = fc.float({
+          noDefaultInfinity: true
+        }).filter(n => !Number.isNaN(n));
+        const components = ast.head !== "" ? [fc.constant(ast.head)] : [];
+        const addArb = ast => {
+          switch (ast._tag) {
+            case "StringKeyword":
+              return components.push(string);
+            case "NumberKeyword":
+              return components.push(number);
+            case "Literal":
+              return components.push(fc.constant(String(ast.literal)));
+            case "Union":
+              return ast.types.forEach(addArb);
           }
-        }
-        const rest = ast.rest.map(annotatedAST => go(annotatedAST.type, ctx, path));
-        return fc => {
-          // ---------------------------------------------
-          // handle elements
-          // ---------------------------------------------
-          let output = fc.tuple(...elements.map(arb => arb(fc)));
-          if (hasOptionals) {
-            const indexes = fc.tuple(...ast.elements.map(element => element.isOptional ? fc.boolean() : fc.constant(true)));
-            output = output.chain(tuple => indexes.map(booleans => {
-              for (const [i, b] of booleans.reverse().entries()) {
-                if (!b) {
-                  tuple.splice(booleans.length - i, 1);
-                }
-              }
-              return tuple;
-            }));
+        };
+        ast.spans.forEach(span => {
+          addArb(span.type);
+          if (span.literal !== "") {
+            components.push(fc.constant(span.literal));
           }
-          // ---------------------------------------------
-          // handle rest element
-          // ---------------------------------------------
-          if (Arr.isNonEmptyReadonlyArray(rest)) {
-            const [head, ...tail] = rest;
-            const item = head(fc);
-            const constraints = ctx.constraints && ctx.constraints._tag === "ArrayConstraints" ? ctx.constraints.constraints : undefined;
-            output = output.chain(as => {
-              return (ctx.depthIdentifier !== undefined ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, constraints) : fc.array(item, constraints)).map(rest => [...as, ...rest]);
-            });
-            // ---------------------------------------------
-            // handle post rest elements
-            // ---------------------------------------------
-            for (let j = 0; j < tail.length; j++) {
-              output = output.chain(as => tail[j](fc).map(a => [...as, a]));
+        });
+        return fc.tuple(...components).map(spans => spans.join(""));
+      });
+    case "Refinement":
+      {
+        const from = toOp(ast.from, ctx, path);
+        const filters = [...from.filters, a => Option.isNone(ast.filter(a, AST.defaultParseOption, ast))];
+        switch (from._tag) {
+          case "Succeed":
+            {
+              return new Succeed(from.lazyArbitrary, filters);
             }
-          }
-          return output;
-        };
+          case "Deferred":
+            {
+              return new Deferred(merge(from.config, getConstraints(from.config._tag, ast)), filters);
+            }
+        }
       }
+    case "TupleType":
+      return new Deferred(makeArrayConfig({}, ast));
     case "TypeLiteral":
       {
         const propertySignaturesTypes = ast.propertySignatures.map(ps => go(ps.type, ctx, path.concat(ps.name)));
         const indexSignatures = ast.indexSignatures.map(is => [go(is.parameter, ctx, path), go(is.type, ctx, path)]);
-        return fc => {
+        return new Succeed(fc => {
           const arbs = {};
           const requiredKeys = [];
           // ---------------------------------------------
@@ -245,238 +308,191 @@ const go = (ast, ctx, path) => {
             });
           }
           return output;
-        };
+        });
       }
     case "Union":
       {
         const types = ast.types.map(member => go(member, ctx, path));
-        return fc => fc.oneof(...types.map(arb => arb(fc)));
-      }
-    case "Enums":
-      {
-        if (ast.enums.length === 0) {
-          throw new Error(errors_.getArbitraryEmptyEnumErrorMessage(path));
-        }
-        return fc => fc.oneof(...ast.enums.map(([_, value]) => fc.constant(value)));
-      }
-    case "Refinement":
-      {
-        const from = getRefinementFromArbitrary(ast, ctx, path);
-        return fc => from(fc).filter(a => Option.isNone(ast.filter(a, AST.defaultParseOption, ast)));
+        return new Succeed(fc => fc.oneof(...types.map(arb => arb(fc))));
       }
     case "Suspend":
       {
         const get = util_.memoizeThunk(() => {
           return go(ast.f(), getSuspendedContext(ctx, ast), path);
         });
-        return fc => fc.constant(null).chain(() => get()(fc));
+        return new Succeed(fc => fc.constant(null).chain(() => get()(fc)));
       }
     case "Transformation":
-      return go(ast.to, ctx, path);
+      return new Succeed(go(ast.to, ctx, path));
   }
 };
-/** @internal */
-export class NumberConstraints {
-  _tag = "NumberConstraints";
-  constraints;
-  constructor(options) {
-    this.constraints = {};
-    if (Predicate.isNumber(options.min)) {
-      this.constraints.min = Math.fround(options.min);
-    }
-    if (Predicate.isNumber(options.max)) {
-      this.constraints.max = Math.fround(options.max);
-    }
-    if (Predicate.isBoolean(options.noNaN)) {
-      this.constraints.noNaN = options.noNaN;
-    }
-    if (Predicate.isBoolean(options.noDefaultInfinity)) {
-      this.constraints.noDefaultInfinity = options.noDefaultInfinity;
+const goTupleType = (ast, ctx, path, constraints) => {
+  const elements = [];
+  let hasOptionals = false;
+  let i = 0;
+  for (const element of ast.elements) {
+    elements.push(go(element.type, ctx, path.concat(i++)));
+    if (element.isOptional) {
+      hasOptionals = true;
     }
   }
-}
-/** @internal */
-export class StringConstraints {
-  _tag = "StringConstraints";
-  constraints;
-  constructor(options) {
-    this.constraints = {};
-    if (Predicate.isNumber(options.minLength)) {
-      this.constraints.minLength = options.minLength;
-    }
-    if (Predicate.isNumber(options.maxLength)) {
-      this.constraints.maxLength = options.maxLength;
-    }
-  }
-}
-/** @internal */
-export class IntegerConstraints {
-  _tag = "IntegerConstraints";
-  constraints;
-  constructor(options) {
-    this.constraints = {};
-    if (Predicate.isNumber(options.min)) {
-      this.constraints.min = options.min;
-    }
-    if (Predicate.isNumber(options.max)) {
-      this.constraints.max = options.max;
-    }
-  }
-}
-/** @internal */
-export class ArrayConstraints {
-  _tag = "ArrayConstraints";
-  constraints;
-  constructor(options) {
-    this.constraints = {};
-    if (Predicate.isNumber(options.minLength)) {
-      this.constraints.minLength = options.minLength;
-    }
-    if (Predicate.isNumber(options.maxLength)) {
-      this.constraints.maxLength = options.maxLength;
-    }
-  }
-}
-/** @internal */
-export class BigIntConstraints {
-  _tag = "BigIntConstraints";
-  constraints;
-  constructor(options) {
-    this.constraints = {};
-    if (Predicate.isBigInt(options.min)) {
-      this.constraints.min = options.min;
+  const rest = ast.rest.map(annotatedAST => go(annotatedAST.type, ctx, path));
+  return fc => {
+    // ---------------------------------------------
+    // handle elements
+    // ---------------------------------------------
+    let output = fc.tuple(...elements.map(arb => arb(fc)));
+    if (hasOptionals) {
+      const indexes = fc.tuple(...ast.elements.map(element => element.isOptional ? fc.boolean() : fc.constant(true)));
+      output = output.chain(tuple => indexes.map(booleans => {
+        for (const [i, b] of booleans.reverse().entries()) {
+          if (!b) {
+            tuple.splice(booleans.length - i, 1);
+          }
+        }
+        return tuple;
+      }));
     }
-    if (Predicate.isBigInt(options.max)) {
-      this.constraints.max = options.max;
+    // ---------------------------------------------
+    // handle rest element
+    // ---------------------------------------------
+    if (Arr.isNonEmptyReadonlyArray(rest)) {
+      const [head, ...tail] = rest;
+      const item = head(fc);
+      output = output.chain(as => {
+        return (ctx.depthIdentifier !== undefined ? getSuspendedArray(fc, ctx.depthIdentifier, ctx.maxDepth, item, constraints) : fc.array(item, constraints)).map(rest => [...as, ...rest]);
+      });
+      // ---------------------------------------------
+      // handle post rest elements
+      // ---------------------------------------------
+      for (let j = 0; j < tail.length; j++) {
+        output = output.chain(as => tail[j](fc).map(a => [...as, a]));
+      }
     }
-  }
-}
-/** @internal */
-export const getConstraints = ast => {
+    return output;
+  };
+};
+const getConstraints = (_tag, ast) => {
   const TypeAnnotationId = ast.annotations[AST.SchemaIdAnnotationId];
-  const jsonSchema = ast.annotations[AST.JSONSchemaAnnotationId];
-  switch (TypeAnnotationId) {
-    // int
-    case filters_.IntSchemaId:
-      return new IntegerConstraints({});
-    // number
-    case filters_.GreaterThanSchemaId:
-    case filters_.GreaterThanOrEqualToSchemaId:
-    case filters_.LessThanSchemaId:
-    case filters_.LessThanOrEqualToSchemaId:
-    case filters_.BetweenSchemaId:
-      return new NumberConstraints({
-        min: jsonSchema.exclusiveMinimum ?? jsonSchema.minimum,
-        max: jsonSchema.exclusiveMaximum ?? jsonSchema.maximum
-      });
-    // bigint
-    case filters_.GreaterThanBigintSchemaId:
-    case filters_.GreaterThanOrEqualToBigIntSchemaId:
-    case filters_.LessThanBigIntSchemaId:
-    case filters_.LessThanOrEqualToBigIntSchemaId:
-    case filters_.BetweenBigintSchemaId:
+  const jsonSchema = Option.getOrElse(AST.getJSONSchemaAnnotation(ast), () => ({}));
+  switch (_tag) {
+    case "StringConstraints":
+      return makeStringConstraints(jsonSchema);
+    case "NumberConstraints":
       {
-        const constraints = ast.annotations[TypeAnnotationId];
-        return new BigIntConstraints(constraints);
+        switch (TypeAnnotationId) {
+          case filters_.NonNaNSchemaId:
+            return makeNumberConstraints({
+              noNaN: true
+            });
+          default:
+            return makeNumberConstraints({
+              isInteger: "type" in jsonSchema && jsonSchema.type === "integer",
+              noNaN: "type" in jsonSchema && jsonSchema.type === "number" ? true : undefined,
+              noDefaultInfinity: "type" in jsonSchema && jsonSchema.type === "number" ? true : undefined,
+              min: jsonSchema.exclusiveMinimum ?? jsonSchema.minimum,
+              minExcluded: "exclusiveMinimum" in jsonSchema ? true : undefined,
+              max: jsonSchema.exclusiveMaximum ?? jsonSchema.maximum,
+              maxExcluded: "exclusiveMaximum" in jsonSchema ? true : undefined
+            });
+        }
       }
-    // string
-    case filters_.MinLengthSchemaId:
-    case filters_.MaxLengthSchemaId:
-    case filters_.LengthSchemaId:
-      return new StringConstraints(jsonSchema);
-    // array
-    case filters_.MinItemsSchemaId:
-    case filters_.MaxItemsSchemaId:
-    case filters_.ItemsCountSchemaId:
-      return new ArrayConstraints({
+    case "BigIntConstraints":
+      return makeBigIntConstraints(ast.annotations[TypeAnnotationId]);
+    case "ArrayConstraints":
+      return makeArrayConstraints({
         minLength: jsonSchema.minItems,
         maxLength: jsonSchema.maxItems
       });
   }
 };
-/** @internal */
-export const combineConstraints = (c1, c2) => {
-  if (c1 === undefined) {
-    return c2;
-  }
-  if (c2 === undefined) {
-    return c1;
-  }
-  switch (c1._tag) {
-    case "ArrayConstraints":
-      {
-        switch (c2._tag) {
-          case "ArrayConstraints":
-            return new ArrayConstraints({
+function getMax(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1;
+}
+function getMin(n1, n2) {
+  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2;
+}
+const getOr = (a, b) => {
+  return a === undefined ? b : b === undefined ? a : a || b;
+};
+const merge = (c1, c2) => {
+  if (c2) {
+    switch (c1._tag) {
+      case "StringConstraints":
+        {
+          if (c2._tag === "StringConstraints") {
+            return makeStringConstraints({
               minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
-              maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
+              maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength),
+              pattern: c1.pattern ?? c2.pattern
             });
+          }
+          break;
         }
-        break;
-      }
-    case "NumberConstraints":
-      {
-        switch (c2._tag) {
-          case "NumberConstraints":
-            return new NumberConstraints({
+      case "NumberConstraints":
+        {
+          if (c2._tag === "NumberConstraints") {
+            return makeNumberConstraints({
+              isInteger: c1.isInteger || c2.isInteger,
               min: getMax(c1.constraints.min, c2.constraints.min),
+              minExcluded: getOr(c1.constraints.minExcluded, c2.constraints.minExcluded),
               max: getMin(c1.constraints.max, c2.constraints.max),
+              maxExcluded: getOr(c1.constraints.maxExcluded, c2.constraints.maxExcluded),
               noNaN: getOr(c1.constraints.noNaN, c2.constraints.noNaN),
               noDefaultInfinity: getOr(c1.constraints.noDefaultInfinity, c2.constraints.noDefaultInfinity)
             });
-          case "IntegerConstraints":
-            return new IntegerConstraints({
-              min: getMax(c1.constraints.min, c2.constraints.min),
-              max: getMin(c1.constraints.max, c2.constraints.max)
-            });
+          }
+          break;
         }
-        break;
-      }
-    case "BigIntConstraints":
-      {
-        switch (c2._tag) {
-          case "BigIntConstraints":
-            return new BigIntConstraints({
+      case "BigIntConstraints":
+        {
+          if (c2._tag === "BigIntConstraints") {
+            return makeBigIntConstraints({
               min: getMax(c1.constraints.min, c2.constraints.min),
               max: getMin(c1.constraints.max, c2.constraints.max)
             });
+          }
+          break;
         }
-        break;
-      }
-    case "StringConstraints":
-      {
-        switch (c2._tag) {
-          case "StringConstraints":
-            return new StringConstraints({
+      case "ArrayConstraints":
+        {
+          if (c2._tag === "ArrayConstraints") {
+            return makeArrayConfig({
               minLength: getMax(c1.constraints.minLength, c2.constraints.minLength),
               maxLength: getMin(c1.constraints.maxLength, c2.constraints.maxLength)
-            });
-        }
-        break;
-      }
-    case "IntegerConstraints":
-      {
-        switch (c2._tag) {
-          case "NumberConstraints":
-          case "IntegerConstraints":
-            {
-              return new IntegerConstraints({
-                min: getMax(c1.constraints.min, c2.constraints.min),
-                max: getMin(c1.constraints.max, c2.constraints.max)
-              });
-            }
+            }, c1.ast);
+          }
+          break;
         }
-        break;
-      }
+    }
   }
+  return c1;
 };
-const getOr = (a, b) => {
-  return a === undefined ? b : b === undefined ? a : a || b;
+const getSuspendedArray = (fc, depthIdentifier, maxDepth, item, constraints) => {
+  let minLength = 1;
+  let maxLength = 2;
+  if (constraints && constraints.minLength !== undefined && constraints.minLength > minLength) {
+    minLength = constraints.minLength;
+    if (minLength > maxLength) {
+      maxLength = minLength;
+    }
+  }
+  return fc.oneof({
+    maxDepth,
+    depthIdentifier
+  }, fc.constant([]), fc.array(item, {
+    minLength,
+    maxLength
+  }));
+};
+const getSuspendedContext = (ctx, ast) => {
+  if (ctx.depthIdentifier !== undefined) {
+    return ctx;
+  }
+  const depthIdentifier = AST.getIdentifierAnnotation(ast).pipe(Option.orElse(() => AST.getIdentifierAnnotation(ast.f())), Option.getOrElse(() => "SuspendDefaultDepthIdentifier"));
+  return {
+    ...ctx,
+    depthIdentifier
+  };
 };
-function getMax(n1, n2) {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n2 : n1;
-}
-function getMin(n1, n2) {
-  return n1 === undefined ? n2 : n2 === undefined ? n1 : n1 <= n2 ? n1 : n2;
-}
 //# sourceMappingURL=Arbitrary.js.map