@fncts/schema 0.0.24 → 0.0.25

package/_cjs/Parser/interpreter.cjs

@@ -1,365 +1,283 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.parserFor = parserFor;
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/data/Either/api"));
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/schema/Parser/definition"));
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/schema/ParseResult"));
-var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/collection/immutable/Vector/api"));
-var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/data/Maybe/api"));
-var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/schema/AST"));
-var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/schema/ParseError/ParseError"));
-var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/collection/immutable/Vector/internal"));
-var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
-var _Global = /*#__PURE__*/require("@fncts/base/data/Global");
-var _predicates = /*#__PURE__*/require("@fncts/base/util/predicates");
-var _AST2 = /*#__PURE__*/require("../AST.cjs");
-var _ParseError2 = /*#__PURE__*/require("../ParseError/ParseError.cjs");
-var _utils = /*#__PURE__*/require("../utils.cjs");
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
-const decodeMemoMap = /*#__PURE__*/(0, _Global.globalValue)(/*#__PURE__*/Symbol.for("fncts.schema.Parser.decodeMemoMap"), () => new WeakMap());
-const encodeMemoMap = /*#__PURE__*/(0, _Global.globalValue)(/*#__PURE__*/Symbol.for("fncts.schema.Parser.encodeMemoMap"), () => new WeakMap());
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../chunk.cjs");
+const require_utils = require("../utils.cjs");
+const require_AST = require("../AST.cjs");
+const require_ParseError_ParseError = require("../ParseError/ParseError.cjs");
+let _fncts_base_collection_immutable_Vector_api = require("@fncts/base/collection/immutable/Vector/api");
+_fncts_base_collection_immutable_Vector_api = require_chunk.__toESM(_fncts_base_collection_immutable_Vector_api, 1);
+let _fncts_schema_AST = require("@fncts/schema/AST");
+_fncts_schema_AST = require_chunk.__toESM(_fncts_schema_AST, 1);
+let _fncts_base_data_Maybe_api = require("@fncts/base/data/Maybe/api");
+_fncts_base_data_Maybe_api = require_chunk.__toESM(_fncts_base_data_Maybe_api, 1);
+let _fncts_base_data_Global = require("@fncts/base/data/Global");
+let _fncts_schema_ParseResult = require("@fncts/schema/ParseResult");
+_fncts_schema_ParseResult = require_chunk.__toESM(_fncts_schema_ParseResult, 1);
+let _fncts_base_data_Maybe_definition = require("@fncts/base/data/Maybe/definition");
+_fncts_base_data_Maybe_definition = require_chunk.__toESM(_fncts_base_data_Maybe_definition, 1);
+let _fncts_base_util_predicates = require("@fncts/base/util/predicates");
+let _fncts_schema_ParseError_ParseError = require("@fncts/schema/ParseError/ParseError");
+_fncts_schema_ParseError_ParseError = require_chunk.__toESM(_fncts_schema_ParseError_ParseError, 1);
+let _fncts_base_collection_immutable_Vector_internal = require("@fncts/base/collection/immutable/Vector/internal");
+_fncts_base_collection_immutable_Vector_internal = require_chunk.__toESM(_fncts_base_collection_immutable_Vector_internal, 1);
+let _fncts_base_data_Either_api = require("@fncts/base/data/Either/api");
+_fncts_base_data_Either_api = require_chunk.__toESM(_fncts_base_data_Either_api, 1);
+let _fncts_schema_Parser_definition = require("@fncts/schema/Parser/definition");
+_fncts_schema_Parser_definition = require_chunk.__toESM(_fncts_schema_Parser_definition, 1);
+//#region build/esm/Parser/interpreter.js
+const decodeMemoMap = (0, _fncts_base_data_Global.globalValue)(Symbol.for("fncts.schema.Parser.decodeMemoMap"), () => /* @__PURE__ */ new WeakMap());
+const encodeMemoMap = (0, _fncts_base_data_Global.globalValue)(Symbol.for("fncts.schema.Parser.encodeMemoMap"), () => /* @__PURE__ */ new WeakMap());
 function goMemo(ast, isDecoding) {
-  const memoMap = isDecoding ? decodeMemoMap : encodeMemoMap;
-  const memo = memoMap.get(ast);
-  if (memo) {
-    return memo;
-  }
-  const parser = go(ast, isDecoding);
-  memoMap.set(ast, parser);
-  return parser;
+	const memoMap = isDecoding ? decodeMemoMap : encodeMemoMap;
+	const memo = memoMap.get(ast);
+	if (memo) return memo;
+	const parser = go(ast, isDecoding);
+	memoMap.set(ast, parser);
+	return parser;
 }
 function go(ast, isDecoding) {
-  void 0;
-  switch (ast._tag) {
-    case 0 /* ASTTag.Declaration */:
-      {
-        const parse = isDecoding ? ast.decode(...ast.typeParameters) : ast.encode(...ast.typeParameters);
-        return tsplus_module_2.make((input, options) => tsplus_module_1.mapLeft(error => new _ParseError2.DeclarationError(ast, input, error))(parse(input, options)));
-      }
-    case 1 /* ASTTag.Literal */:
-      return tsplus_module_2.fromRefinement(ast, u => u === ast.literal);
-    case 2 /* ASTTag.UniqueSymbol */:
-      return tsplus_module_2.fromRefinement(ast, u => u === ast.symbol);
-    case 3 /* ASTTag.UndefinedKeyword */:
-    case 4 /* ASTTag.VoidKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isUndefined);
-    case 5 /* ASTTag.NeverKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _ => false);
-    case 6 /* ASTTag.UnknownKeyword */:
-    case 7 /* ASTTag.AnyKeyword */:
-      return tsplus_module_2.make(tsplus_module_3.succeed);
-    case 8 /* ASTTag.StringKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isString);
-    case 9 /* ASTTag.NumberKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isNumber);
-    case 10 /* ASTTag.BooleanKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isBoolean);
-    case 11 /* ASTTag.BigIntKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isBigInt);
-    case 12 /* ASTTag.SymbolKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isSymbol);
-    case 13 /* ASTTag.ObjectKeyword */:
-      return tsplus_module_2.fromRefinement(ast, _predicates.isObject);
-    case 14 /* ASTTag.Enum */:
-      return tsplus_module_2.fromRefinement(ast, u => tsplus_module_4.some(([_, value]) => value === u)(ast.enums));
-    case 15 /* ASTTag.TemplateLiteral */:
-      {
-        const regex = (0, _utils.getTemplateLiteralRegex)(ast);
-        return tsplus_module_2.fromRefinement(ast, u => (0, _predicates.isString)(u) && regex.test(u));
-      }
-    case 16 /* ASTTag.Tuple */:
-      {
-        const elements = tsplus_module_4.map(e => goMemo(e.type, isDecoding))(ast.elements);
-        const rest = tsplus_module_5.map(rest => tsplus_module_4.map(ast => goMemo(ast, isDecoding))(rest))(ast.rest);
-        return tsplus_module_2.make((input, options) => {
-          if (!Array.isArray(input)) {
-            return tsplus_module_3.fail(tsplus_module_7.typeError(tsplus_module_6.unknownArray, input));
-          }
-          const output = [];
-          const errors = tsplus_module_4.emptyPushable();
-          const allErrors = options?.allErrors;
-          let i = 0;
-          for (; i < elements.length; i++) {
-            if (input.length < i + 1) {
-              if (!tsplus_module_4.unsafeGet(i)(ast.elements).isOptional) {
-                const e = tsplus_module_7.indexError(i, tsplus_module_7.missingError);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-            } else {
-              const parser = tsplus_module_4.unsafeGet(i)(elements);
-              const t = parser(input[i], options);
-              void 0;
-              if (tsplus_module_1.isLeft(t)) {
-                const e = tsplus_module_7.indexError(i, t.left);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-              output.push(t.right);
-            }
-          }
-          if (tsplus_module_9.isJust(rest)) {
-            const head = tsplus_module_4.unsafeHead(rest.value);
-            const tail = tsplus_module_4.tail(rest.value);
-            for (; i < input.length - tail.length; i++) {
-              const t = head(input[i], options);
-              void 0;
-              if (tsplus_module_1.isLeft(t)) {
-                const e = tsplus_module_7.indexError(i, t.left);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-              output.push(t.right);
-            }
-            for (let j = 0; j < tail.length; j++) {
-              i += j;
-              if (input.length < i + 1) {
-                const e = tsplus_module_7.indexError(i, tsplus_module_7.missingError);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              } else {
-                const t = tsplus_module_4.unsafeGet(j)(tail)(input[i], options);
-                void 0;
-                if (tsplus_module_1.isLeft(t)) {
-                  const e = tsplus_module_7.indexError(i, t.left);
-                  if (allErrors) {
-                    tsplus_module_8.push(e)(errors);
-                    continue;
-                  } else {
-                    return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                  }
-                }
-                output.push(t.right);
-              }
-            }
-          } else {
-            const isUnexpectedAllowed = options?.isUnexpectedAllowed;
-            for (; i < input.length; i++) {
-              const e = tsplus_module_7.indexError(i, tsplus_module_7.unexpectedError(input[i]));
-              if (!isUnexpectedAllowed) {
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-            }
-          }
-          return tsplus_module_4.isNonEmpty(errors) ? tsplus_module_3.fail(tsplus_module_7.tupleError(ast, input, errors, output)) : tsplus_module_3.succeed(output);
-        });
-      }
-    case 17 /* ASTTag.TypeLiteral */:
-      {
-        if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) {
-          return tsplus_module_2.fromRefinement(ast, u => u !== null);
-        }
-        const propertySignatureTypes = tsplus_module_4.map(f => goMemo(f.type, isDecoding))(ast.propertySignatures);
-        const indexSignatures = tsplus_module_4.map(is => [goMemo(is.parameter, isDecoding), goMemo(is.type, isDecoding)])(ast.indexSignatures);
-        return tsplus_module_2.make((input, options) => {
-          if (!(0, _predicates.isRecord)(input)) {
-            return tsplus_module_3.fail(tsplus_module_7.typeError(tsplus_module_6.unknownRecord, input));
-          }
-          const output = {};
-          const expectedKeys = {};
-          const errors = tsplus_module_4.emptyPushable();
-          const allErrors = options?.allErrors;
-          for (let i = 0; i < propertySignatureTypes.length; i++) {
-            const ps = tsplus_module_4.unsafeGet(i)(ast.propertySignatures);
-            const parser = tsplus_module_4.unsafeGet(i)(propertySignatureTypes);
-            const name = ps.name;
-            expectedKeys[name] = null;
-            if (!Object.prototype.hasOwnProperty.call(input, name)) {
-              if (!ps.isOptional) {
-                const e = tsplus_module_7.keyError(tsplus_module_6.createKey(name), name, tsplus_module_7.missingError);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-            } else {
-              const t = parser(input[name], options);
-              void 0;
-              if (tsplus_module_1.isLeft(t)) {
-                const e = tsplus_module_7.keyError(tsplus_module_6.createKey(name), name, t.left);
-                if (allErrors) {
-                  tsplus_module_8.push(e)(errors);
-                  continue;
-                } else {
-                  return tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, tsplus_module_4.vector(e), output));
-                }
-              }
-              output[name] = t.right;
-            }
-          }
-          if (indexSignatures.length > 0) {
-            for (let i = 0; i < indexSignatures.length; i++) {
-              const [parameter, type] = tsplus_module_4.unsafeGet(i)(indexSignatures);
-              const keys = (0, _utils.getKeysForIndexSignature)(input, tsplus_module_4.unsafeGet(i)(ast.indexSignatures).parameter);
-              for (const key of keys) {
-                if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
-                  continue;
-                }
-                let t = parameter(key, options);
-                void 0;
-                if (tsplus_module_1.isLeft(t)) {
-                  const e = tsplus_module_7.keyError(tsplus_module_6.createKey(key), key, t.left);
-                  if (allErrors) {
-                    tsplus_module_8.push(e)(errors);
-                    continue;
-                  } else {
-                    return tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, tsplus_module_4.vector(e), output));
-                  }
-                }
-                t = type(input[key], options);
-                void 0;
-                if (tsplus_module_1.isLeft(t)) {
-                  const e = tsplus_module_7.keyError(tsplus_module_6.createKey(key), key, t.left);
-                  tsplus_module_8.push(e)(errors);
-                  if (allErrors) {
-                    continue;
-                  } else {
-                    return tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, tsplus_module_4.vector(e), output));
-                  }
-                }
-                output[key] = t.right;
-              }
-            }
-          } else {
-            const isUnexpectedAllowed = options?.isUnexpectedAllowed;
-            for (const key of (0, _utils.ownKeys)(input)) {
-              if (!Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
-                if (!isUnexpectedAllowed) {
-                  const e = tsplus_module_7.keyError(tsplus_module_6.createKey(key), key, tsplus_module_7.unexpectedError(input[key]));
-                  if (allErrors) {
-                    tsplus_module_8.push(e)(errors);
-                    continue;
-                  } else {
-                    return tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, tsplus_module_4.vector(e), output));
-                  }
-                }
-              }
-            }
-          }
-          return tsplus_module_4.isNonEmpty(errors) ? tsplus_module_3.fail(tsplus_module_7.typeLiteralError(ast, input, errors, output)) : tsplus_module_3.succeed(output);
-        });
-      }
-    case 18 /* ASTTag.Union */:
-      {
-        const searchTree = (0, _AST2.getSearchTree)(ast.types, isDecoding);
-        const ownKeys = Reflect.ownKeys(searchTree.keys);
-        const len = ownKeys.length;
-        const map = new Map();
-        tsplus_module_4.forEach(ast => {
-          map.set(ast, goMemo(ast, isDecoding));
-        })(ast.types);
-        return tsplus_module_2.make((input, options) => {
-          const errors = tsplus_module_4.emptyPushable();
-          let candidates = [];
-          if (len > 0) {
-            if ((0, _predicates.isRecord)(input)) {
-              for (let i = 0; i < len; i++) {
-                const name = ownKeys[i];
-                const buckets = searchTree.keys[name].buckets;
-                if (Object.prototype.hasOwnProperty.call(input, name)) {
-                  const literal = String(input[name]);
-                  if (Object.prototype.hasOwnProperty.call(buckets, literal)) {
-                    candidates = candidates.concat(buckets[literal]);
-                  } else {
-                    const literals = tsplus_module_6.createUnion(tsplus_module_4.from(searchTree.keys[name].literals));
-                    tsplus_module_8.push(tsplus_module_7.typeLiteralError(tsplus_module_6.createTypeLiteral(tsplus_module_4.vector(tsplus_module_6.createPropertySignature(name, literals, false, true)), tsplus_module_4.vector()), input, tsplus_module_4.vector(tsplus_module_7.keyError(tsplus_module_6.createKey(name), name, tsplus_module_7.typeError(searchTree.keys[name].ast, input[name])))))(errors);
-                  }
-                } else {
-                  const literals = tsplus_module_6.createUnion(tsplus_module_4.from(searchTree.keys[name].literals));
-                  tsplus_module_8.push(tsplus_module_7.typeLiteralError(tsplus_module_6.createTypeLiteral(tsplus_module_4.vector(tsplus_module_6.createPropertySignature(name, literals, false, true)), tsplus_module_4.vector()), input, tsplus_module_4.vector(tsplus_module_7.keyError(tsplus_module_6.createKey(name), name, tsplus_module_7.missingError))))(errors);
-                }
-              }
-            } else {
-              tsplus_module_8.push(tsplus_module_7.typeError(tsplus_module_6.unknownRecord, input))(errors);
-            }
-          }
-          if (searchTree.otherwise.length > 0) {
-            candidates = candidates.concat(searchTree.otherwise);
-          }
-          for (let i = 0; i < candidates.length; i++) {
-            const candidate = candidates[i];
-            const pr = map.get(candidate)(input, options);
-            void 0;
-            if (tsplus_module_1.isRight(pr)) {
-              return pr;
-            } else {
-              tsplus_module_8.push(tsplus_module_7.unionMemberError(candidate, pr.left))(errors);
-            }
-          }
-          return tsplus_module_4.isNonEmpty(errors) ? errors.length === 1 && tsplus_module_4.unsafeGet(0)(errors)._tag === 1 /* ParseErrorTag.Type */ ? tsplus_module_3.fail(tsplus_module_4.unsafeGet(0)(errors)) : tsplus_module_3.fail(tsplus_module_7.unionError(ast, input, tsplus_module_4.from(errors))) : tsplus_module_3.fail(tsplus_module_7.typeError(tsplus_module_6.neverKeyword, input));
-        });
-      }
-    case 19 /* ASTTag.Lazy */:
-      {
-        const f = () => goMemo(ast.getAST(), isDecoding);
-        const get = (0, _utils.memoize)(f);
-        return tsplus_module_2.make((a, options) => get()(a, options));
-      }
-    case 20 /* ASTTag.Refinement */:
-      {
-        if (isDecoding) {
-          const from = goMemo(ast.from, isDecoding);
-          return tsplus_module_2.make((input, options) => tsplus_module_1.flatMap(a => tsplus_module_1.mapLeft(failure => tsplus_module_7.refinementError(ast, input, "Predicate", failure))(ast.decode(a, options)))(tsplus_module_1.mapLeft(failure => tsplus_module_7.refinementError(ast, input, "From", failure))(from(input, options))));
-        } else {
-          const from = goMemo(ast.from, true);
-          const to = goMemo(tsplus_module_6.getTo(ast.from), false);
-          return tsplus_module_2.make((input, options) => tsplus_module_1.flatMap(a => from(a, options))(tsplus_module_1.flatMap(a => ast.decode(a, options))(to(input, options))));
-        }
-      }
-    case 21 /* ASTTag.Transform */:
-      {
-        const transformation = isDecoding ? ast.decode : ast.encode;
-        const from = isDecoding ? goMemo(ast.from, true) : goMemo(ast.to, false);
-        const to = isDecoding ? goMemo(ast.to, true) : goMemo(ast.from, false);
-        return tsplus_module_2.make((input, options) => tsplus_module_1.flatMap(a => tsplus_module_1.mapLeft(failure => tsplus_module_7.transformationError(ast, input, isDecoding ? "Type" : "Encoded", failure))(to(a, options)))(tsplus_module_1.flatMap(a => tsplus_module_1.mapLeft(failure => tsplus_module_7.transformationError(ast, input, "Transformation", failure))(transformation(a, options)))(tsplus_module_1.mapLeft(failure => tsplus_module_7.transformationError(ast, input, isDecoding ? "Encoded" : "Type", failure))(from(input, options)))));
-      }
-    case 22 /* ASTTag.Validation */:
-      {
-        return tsplus_module_2.make((u, options) => {
-          const missedBrands = tsplus_module_4.emptyPushable();
-          const allErrors = options?.allErrors;
-          for (const validation of ast.validation) {
-            if (!validation.validate(u)) {
-              tsplus_module_8.push(validation)(missedBrands);
-              if (allErrors) {
-                continue;
-              } else {
-                return tsplus_module_3.fail(tsplus_module_7.typeError(tsplus_module_6.createValidation(ast.from, missedBrands, ast.annotations), u));
-              }
-            }
-          }
-          return missedBrands.length > 0 ? tsplus_module_3.fail(tsplus_module_7.typeError(tsplus_module_6.createValidation(ast.from, missedBrands, ast.annotations), u)) : tsplus_module_3.succeed(u);
-        });
-      }
-  }
+	switch (ast._tag) {
+		case 0: {
+			const parse = isDecoding ? ast.decode(...ast.typeParameters) : ast.encode(...ast.typeParameters);
+			return _fncts_schema_Parser_definition.make((input, options) => _fncts_base_data_Either_api.mapLeft((error) => new require_ParseError_ParseError.DeclarationError(ast, input, error))(parse(input, options)));
+		}
+		case 1: return _fncts_schema_Parser_definition.fromRefinement(ast, (u) => u === ast.literal);
+		case 2: return _fncts_schema_Parser_definition.fromRefinement(ast, (u) => u === ast.symbol);
+		case 3:
+		case 4: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isUndefined);
+		case 5: return _fncts_schema_Parser_definition.fromRefinement(ast, (_) => false);
+		case 6:
+		case 7: return _fncts_schema_Parser_definition.make(_fncts_schema_ParseResult.succeed);
+		case 8: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isString);
+		case 9: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isNumber);
+		case 10: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isBoolean);
+		case 11: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isBigInt);
+		case 12: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isSymbol);
+		case 13: return _fncts_schema_Parser_definition.fromRefinement(ast, _fncts_base_util_predicates.isObject);
+		case 14: return _fncts_schema_Parser_definition.fromRefinement(ast, (u) => _fncts_base_collection_immutable_Vector_api.some(([_, value]) => value === u)(ast.enums));
+		case 15: {
+			const regex = require_utils.getTemplateLiteralRegex(ast);
+			return _fncts_schema_Parser_definition.fromRefinement(ast, (u) => (0, _fncts_base_util_predicates.isString)(u) && regex.test(u));
+		}
+		case 16: {
+			const elements = _fncts_base_collection_immutable_Vector_api.map((e) => goMemo(e.type, isDecoding))(ast.elements);
+			const rest = _fncts_base_data_Maybe_api.map((rest) => _fncts_base_collection_immutable_Vector_api.map((ast) => goMemo(ast, isDecoding))(rest))(ast.rest);
+			return _fncts_schema_Parser_definition.make((input, options) => {
+				if (!Array.isArray(input)) return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.unknownArray, input));
+				const output = [];
+				const errors = _fncts_base_collection_immutable_Vector_api.emptyPushable();
+				const allErrors = options?.allErrors;
+				let i = 0;
+				for (; i < elements.length; i++) if (input.length < i + 1) {
+					if (!_fncts_base_collection_immutable_Vector_api.unsafeGet(i)(ast.elements).isOptional) {
+						const e = _fncts_schema_ParseError_ParseError.indexError(i, _fncts_schema_ParseError_ParseError.missingError);
+						if (allErrors) {
+							_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+							continue;
+						} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+					}
+				} else {
+					const t = _fncts_base_collection_immutable_Vector_api.unsafeGet(i)(elements)(input[i], options);
+					if (_fncts_base_data_Either_api.isLeft(t)) {
+						const e = _fncts_schema_ParseError_ParseError.indexError(i, t.left);
+						if (allErrors) {
+							_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+							continue;
+						} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+					}
+					output.push(t.right);
+				}
+				if (_fncts_base_data_Maybe_definition.isJust(rest)) {
+					const head = _fncts_base_collection_immutable_Vector_api.unsafeHead(rest.value);
+					const tail = _fncts_base_collection_immutable_Vector_api.tail(rest.value);
+					for (; i < input.length - tail.length; i++) {
+						const t = head(input[i], options);
+						if (_fncts_base_data_Either_api.isLeft(t)) {
+							const e = _fncts_schema_ParseError_ParseError.indexError(i, t.left);
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+						output.push(t.right);
+					}
+					for (let j = 0; j < tail.length; j++) {
+						i += j;
+						if (input.length < i + 1) {
+							const e = _fncts_schema_ParseError_ParseError.indexError(i, _fncts_schema_ParseError_ParseError.missingError);
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						} else {
+							const t = _fncts_base_collection_immutable_Vector_api.unsafeGet(j)(tail)(input[i], options);
+							if (_fncts_base_data_Either_api.isLeft(t)) {
+								const e = _fncts_schema_ParseError_ParseError.indexError(i, t.left);
+								if (allErrors) {
+									_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+									continue;
+								} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+							}
+							output.push(t.right);
+						}
+					}
+				} else {
+					const isUnexpectedAllowed = options?.isUnexpectedAllowed;
+					for (; i < input.length; i++) {
+						const e = _fncts_schema_ParseError_ParseError.indexError(i, _fncts_schema_ParseError_ParseError.unexpectedError(input[i]));
+						if (!isUnexpectedAllowed) if (allErrors) {
+							_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+							continue;
+						} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+					}
+				}
+				return _fncts_base_collection_immutable_Vector_api.isNonEmpty(errors) ? _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.tupleError(ast, input, errors, output)) : _fncts_schema_ParseResult.succeed(output);
+			});
+		}
+		case 17: {
+			if (ast.propertySignatures.length === 0 && ast.indexSignatures.length === 0) return _fncts_schema_Parser_definition.fromRefinement(ast, (u) => u !== null);
+			const propertySignatureTypes = _fncts_base_collection_immutable_Vector_api.map((f) => goMemo(f.type, isDecoding))(ast.propertySignatures);
+			const indexSignatures = _fncts_base_collection_immutable_Vector_api.map((is) => [goMemo(is.parameter, isDecoding), goMemo(is.type, isDecoding)])(ast.indexSignatures);
+			return _fncts_schema_Parser_definition.make((input, options) => {
+				if (!(0, _fncts_base_util_predicates.isRecord)(input)) return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.unknownRecord, input));
+				const output = {};
+				const expectedKeys = {};
+				const errors = _fncts_base_collection_immutable_Vector_api.emptyPushable();
+				const allErrors = options?.allErrors;
+				for (let i = 0; i < propertySignatureTypes.length; i++) {
+					const ps = _fncts_base_collection_immutable_Vector_api.unsafeGet(i)(ast.propertySignatures);
+					const parser = _fncts_base_collection_immutable_Vector_api.unsafeGet(i)(propertySignatureTypes);
+					const name = ps.name;
+					expectedKeys[name] = null;
+					if (!Object.prototype.hasOwnProperty.call(input, name)) {
+						if (!ps.isOptional) {
+							const e = _fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(name), name, _fncts_schema_ParseError_ParseError.missingError);
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+					} else {
+						const t = parser(input[name], options);
+						if (_fncts_base_data_Either_api.isLeft(t)) {
+							const e = _fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(name), name, t.left);
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+						output[name] = t.right;
+					}
+				}
+				if (indexSignatures.length > 0) for (let i = 0; i < indexSignatures.length; i++) {
+					const [parameter, type] = _fncts_base_collection_immutable_Vector_api.unsafeGet(i)(indexSignatures);
+					const keys = require_utils.getKeysForIndexSignature(input, _fncts_base_collection_immutable_Vector_api.unsafeGet(i)(ast.indexSignatures).parameter);
+					for (const key of keys) {
+						if (Object.prototype.hasOwnProperty.call(expectedKeys, key)) continue;
+						let t = parameter(key, options);
+						if (_fncts_base_data_Either_api.isLeft(t)) {
+							const e = _fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(key), key, t.left);
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+						t = type(input[key], options);
+						if (_fncts_base_data_Either_api.isLeft(t)) {
+							const e = _fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(key), key, t.left);
+							_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+							if (allErrors) continue;
+							else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+						output[key] = t.right;
+					}
+				}
+				else {
+					const isUnexpectedAllowed = options?.isUnexpectedAllowed;
+					for (const key of require_utils.ownKeys(input)) if (!Object.prototype.hasOwnProperty.call(expectedKeys, key)) {
+						if (!isUnexpectedAllowed) {
+							const e = _fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(key), key, _fncts_schema_ParseError_ParseError.unexpectedError(input[key]));
+							if (allErrors) {
+								_fncts_base_collection_immutable_Vector_internal.push(e)(errors);
+								continue;
+							} else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, _fncts_base_collection_immutable_Vector_api.vector(e), output));
+						}
+					}
+				}
+				return _fncts_base_collection_immutable_Vector_api.isNonEmpty(errors) ? _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeLiteralError(ast, input, errors, output)) : _fncts_schema_ParseResult.succeed(output);
+			});
+		}
+		case 18: {
+			const searchTree = require_AST.getSearchTree(ast.types, isDecoding);
+			const ownKeys = Reflect.ownKeys(searchTree.keys);
+			const len = ownKeys.length;
+			const map = /* @__PURE__ */ new Map();
+			_fncts_base_collection_immutable_Vector_api.forEach((ast) => {
+				map.set(ast, goMemo(ast, isDecoding));
+			})(ast.types);
+			return _fncts_schema_Parser_definition.make((input, options) => {
+				const errors = _fncts_base_collection_immutable_Vector_api.emptyPushable();
+				let candidates = [];
+				if (len > 0) if ((0, _fncts_base_util_predicates.isRecord)(input)) for (let i = 0; i < len; i++) {
+					const name = ownKeys[i];
+					const buckets = searchTree.keys[name].buckets;
+					if (Object.prototype.hasOwnProperty.call(input, name)) {
+						const literal = String(input[name]);
+						if (Object.prototype.hasOwnProperty.call(buckets, literal)) candidates = candidates.concat(buckets[literal]);
+						else {
+							const literals = _fncts_schema_AST.createUnion(_fncts_base_collection_immutable_Vector_api.from(searchTree.keys[name].literals));
+							_fncts_base_collection_immutable_Vector_internal.push(_fncts_schema_ParseError_ParseError.typeLiteralError(_fncts_schema_AST.createTypeLiteral(_fncts_base_collection_immutable_Vector_api.vector(_fncts_schema_AST.createPropertySignature(name, literals, false, true)), _fncts_base_collection_immutable_Vector_api.vector()), input, _fncts_base_collection_immutable_Vector_api.vector(_fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(name), name, _fncts_schema_ParseError_ParseError.typeError(searchTree.keys[name].ast, input[name])))))(errors);
+						}
+					} else {
+						const literals = _fncts_schema_AST.createUnion(_fncts_base_collection_immutable_Vector_api.from(searchTree.keys[name].literals));
+						_fncts_base_collection_immutable_Vector_internal.push(_fncts_schema_ParseError_ParseError.typeLiteralError(_fncts_schema_AST.createTypeLiteral(_fncts_base_collection_immutable_Vector_api.vector(_fncts_schema_AST.createPropertySignature(name, literals, false, true)), _fncts_base_collection_immutable_Vector_api.vector()), input, _fncts_base_collection_immutable_Vector_api.vector(_fncts_schema_ParseError_ParseError.keyError(_fncts_schema_AST.createKey(name), name, _fncts_schema_ParseError_ParseError.missingError))))(errors);
+					}
+				}
+				else _fncts_base_collection_immutable_Vector_internal.push(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.unknownRecord, input))(errors);
+				if (searchTree.otherwise.length > 0) candidates = candidates.concat(searchTree.otherwise);
+				for (let i = 0; i < candidates.length; i++) {
+					const candidate = candidates[i];
+					const pr = map.get(candidate)(input, options);
+					if (_fncts_base_data_Either_api.isRight(pr)) return pr;
+					else _fncts_base_collection_immutable_Vector_internal.push(_fncts_schema_ParseError_ParseError.unionMemberError(candidate, pr.left))(errors);
+				}
+				return _fncts_base_collection_immutable_Vector_api.isNonEmpty(errors) ? errors.length === 1 && _fncts_base_collection_immutable_Vector_api.unsafeGet(0)(errors)._tag === 1 ? _fncts_schema_ParseResult.fail(_fncts_base_collection_immutable_Vector_api.unsafeGet(0)(errors)) : _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.unionError(ast, input, _fncts_base_collection_immutable_Vector_api.from(errors))) : _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.neverKeyword, input));
+			});
+		}
+		case 19: {
+			const f = () => goMemo(ast.getAST(), isDecoding);
+			const get = require_utils.memoize(f);
+			return _fncts_schema_Parser_definition.make((a, options) => get()(a, options));
+		}
+		case 20: if (isDecoding) {
+			const from = goMemo(ast.from, isDecoding);
+			return _fncts_schema_Parser_definition.make((input, options) => _fncts_base_data_Either_api.flatMap((a) => _fncts_base_data_Either_api.mapLeft((failure) => _fncts_schema_ParseError_ParseError.refinementError(ast, input, "Predicate", failure))(ast.decode(a, options)))(_fncts_base_data_Either_api.mapLeft((failure) => _fncts_schema_ParseError_ParseError.refinementError(ast, input, "From", failure))(from(input, options))));
+		} else {
+			const from = goMemo(ast.from, true);
+			const to = goMemo(_fncts_schema_AST.getTo(ast.from), false);
+			return _fncts_schema_Parser_definition.make((input, options) => _fncts_base_data_Either_api.flatMap((a) => from(a, options))(_fncts_base_data_Either_api.flatMap((a) => ast.decode(a, options))(to(input, options))));
+		}
+		case 21: {
+			const transformation = isDecoding ? ast.decode : ast.encode;
+			const from = isDecoding ? goMemo(ast.from, true) : goMemo(ast.to, false);
+			const to = isDecoding ? goMemo(ast.to, true) : goMemo(ast.from, false);
+			return _fncts_schema_Parser_definition.make((input, options) => _fncts_base_data_Either_api.flatMap((a) => _fncts_base_data_Either_api.mapLeft((failure) => _fncts_schema_ParseError_ParseError.transformationError(ast, input, isDecoding ? "Type" : "Encoded", failure))(to(a, options)))(_fncts_base_data_Either_api.flatMap((a) => _fncts_base_data_Either_api.mapLeft((failure) => _fncts_schema_ParseError_ParseError.transformationError(ast, input, "Transformation", failure))(transformation(a, options)))(_fncts_base_data_Either_api.mapLeft((failure) => _fncts_schema_ParseError_ParseError.transformationError(ast, input, isDecoding ? "Encoded" : "Type", failure))(from(input, options)))));
+		}
+		case 22: return _fncts_schema_Parser_definition.make((u, options) => {
+			const missedBrands = _fncts_base_collection_immutable_Vector_api.emptyPushable();
+			const allErrors = options?.allErrors;
+			for (const validation of ast.validation) if (!validation.validate(u)) {
+				_fncts_base_collection_immutable_Vector_internal.push(validation)(missedBrands);
+				if (allErrors) continue;
+				else return _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.createValidation(ast.from, missedBrands, ast.annotations), u));
+			}
+			return missedBrands.length > 0 ? _fncts_schema_ParseResult.fail(_fncts_schema_ParseError_ParseError.typeError(_fncts_schema_AST.createValidation(ast.from, missedBrands, ast.annotations), u)) : _fncts_schema_ParseResult.succeed(u);
+		});
+	}
 }
 function parserFor(ast, isDecoding) {
-  return goMemo(ast, isDecoding);
+	return goMemo(ast, isDecoding);
 }
+//#endregion
+exports.parserFor = parserFor;
+
 //# sourceMappingURL=interpreter.cjs.map