@fncts/schema 0.0.13 → 0.0.15

package/AST.d.ts

@@ -1,6 +1,7 @@
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { ParseResult } from "@fncts/schema/ParseResult";
+import { ParseError } from "@fncts/schema/ParseError";
 import type { Validation as ValidationType } from "@fncts/base/data/Branded";
 import { ASTAnnotation } from "./ASTAnnotation.js";
 import { ASTAnnotationMap } from "./ASTAnnotationMap.js";
@@ -314,6 +315,11 @@ export declare class Tuple extends AST {
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createTuple(elements: Vector<Element>, rest: Maybe<Vector<AST>>, isReadonly: boolean, annotations?: ASTAnnotationMap): Tuple;
+/**
+ * @tsplus static fncts.schema.ASTOps unknownArray
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const unknownArray: Tuple;
 export declare class PropertySignature extends AST {
     readonly name: PropertyKey;
     readonly type: AST;
@@ -358,6 +364,11 @@ export declare function isTypeLiteral(self: AST): self is TypeLiteral;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function createTypeLiteral(propertySignatures: Vector<PropertySignature>, indexSignatures: Vector<IndexSignature>, annotations?: ASTAnnotationMap): TypeLiteral;
+/**
+ * @tsplus static fncts.schema.ASTOps unknownRecord
+ * @tsplus location "@fncts/schema/AST"
+ */
+export declare const unknownRecord: TypeLiteral;
 export declare class Union extends AST {
     readonly types: Vector<AST>;
     readonly annotations: ASTAnnotationMap;
@@ -394,18 +405,18 @@ export declare function createLazy(getAST: () => AST, annotations?: ASTAnnotatio
 export declare function isLazy(self: AST): self is Lazy;
 export declare class Refinement extends AST {
     readonly from: AST;
-    readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>;
-    readonly isReversed: boolean;
+    readonly predicate: (input: any) => boolean;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Refinement;
-    constructor(from: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap);
+    constructor(from: AST, predicate: (input: any) => boolean, annotations?: ASTAnnotationMap);
+    decode(input: any, options?: ParseOptions): ParseResult<any>;
     clone(newProperties: Partial<this>): AST;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createRefinement
  * @tsplus location "@fncts/schema/AST"
  */
-export declare function createRefinement(from: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap): Refinement;
+export declare function createRefinement(from: AST, predicate: (input: any) => boolean, annotations?: ASTAnnotationMap): Refinement;
 export declare function isRefinement(self: AST): self is Refinement;
 export interface ParseOptions {
     readonly isUnexpectedAllowed?: boolean;
@@ -416,17 +427,16 @@ export declare class Transform extends AST {
     readonly to: AST;
     readonly decode: (input: any, options?: ParseOptions) => ParseResult<any>;
     readonly encode: (input: any, options?: ParseOptions) => ParseResult<any>;
-    readonly isReversed: boolean;
     readonly annotations: ASTAnnotationMap;
     readonly _tag = ASTTag.Transform;
-    constructor(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap);
+    constructor(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap);
     clone(newProperties: Partial<this>): AST;
 }
 /**
  * @tsplus static fncts.schema.ASTOps createTransform
  * @tsplus location "@fncts/schema/AST"
  */
-export declare function createTransform(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, isReversed: boolean, annotations?: ASTAnnotationMap): Transform;
+export declare function createTransform(from: AST, to: AST, decode: (input: any, options?: ParseOptions) => ParseResult<any>, encode: (input: any, options?: ParseOptions) => ParseResult<any>, annotations?: ASTAnnotationMap): Transform;
 export declare class Validation extends AST {
     readonly from: AST;
     readonly validation: Vector<ValidationType<any, string>>;
@@ -516,13 +526,20 @@ export declare function getFrom(ast: AST): AST;
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function getTo(ast: AST): AST;
-/**
- * @tsplus getter fncts.schema.AST reverse
- * @tsplus location "@fncts/schema/AST"
- */
-export declare function reverse(ast: AST): AST;
 /**
  * @tsplus static fncts.schema.AST getCompiler
  * @tsplus location "@fncts/schema/AST"
  */
 export declare function getCompiler<A>(match: AST.Match<A>): AST.Compiler<A>;
+export declare function getLiterals(ast: AST, isDecoding: boolean): ReadonlyArray<[PropertyKey, Literal]>;
+export declare function getSearchTree(members: Vector<AST>, isDecoding: boolean): {
+    keys: {
+        readonly [key: PropertyKey]: {
+            buckets: {
+                [literal: string]: ReadonlyArray<AST>;
+            };
+            ast: AST;
+        };
+    };
+    otherwise: ReadonlyArray<AST>;
+};

package/Guard.d.ts

@@ -0,0 +1,9 @@
+import { Schema } from "@fncts/schema/Schema/definition";
+import { Guard } from "@fncts/base/data/Guard";
+import { AST } from "@fncts/schema/AST";
+/**
+ * @tsplus getter fncts.schema.Schema is
+ * @tsplus location "@fncts/schema/Guard"
+ */
+export declare function is<A>(schema: Schema<A>): (input: unknown) => input is A;
+export declare function guardFor<A>(schema: Schema<A>): Guard<A>;

package/ParseError.d.ts

@@ -2,19 +2,22 @@ import { AST } from "@fncts/schema/AST";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+import type { Refinement, Transform } from "@fncts/schema/AST";
 export declare const enum ParseErrorTag {
     Type = 0,
     Index = 1,
     Key = 2,
     Missing = 3,
     Unexpected = 4,
-    UnionMember = 5
+    UnionMember = 5,
+    Refinement = 6,
+    Transformation = 7
 }
 /**
  * @tsplus type fncts.schema.ParseError
  * @tsplus companion fncts.schema.ParseErrorOps
  */
-export type ParseError = TypeError | IndexError | KeyError | MissingError | UnexpectedError | UnexpectedError | UnionMemberError;
+export type ParseError = TypeError | IndexError | KeyError | MissingError | UnexpectedError | UnionMemberError | RefinementError | TransformationError;
 /**
  * @tsplus companion fncts.schema.ParseError.TypeError
  */
@@ -56,7 +59,7 @@ export declare class KeyError {
     constructor(keyAST: AST, key: any, errors: Vector<ParseError>);
 }
 /**
- * @tsplus static fncts.schema.ParseError.IndexError __call
+ * @tsplus static fncts.schema.ParseError.KeyError __call
  * @tsplus static fncts.schema.ParseErrorOps KeyError
  * @tsplus location "@fncts/schema/ParseError"
  */
@@ -100,6 +103,40 @@ export declare class UnionMemberError {
  * @tsplus location "@fncts/schema/ParseError"
  */
 export declare function unionMemberError(errors: Vector<ParseError>): ParseError;
+/**
+ * @tsplus companion fncts.schema.ParseError.RefinementError
+ */
+export declare class RefinementError {
+    readonly ast: Refinement;
+    readonly actual: unknown;
+    readonly kind: "From" | "Predicate";
+    readonly errors: Vector<ParseError>;
+    readonly _tag = ParseErrorTag.Refinement;
+    constructor(ast: Refinement, actual: unknown, kind: "From" | "Predicate", errors: Vector<ParseError>);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.RefinementError __call
+ * @tsplus static fncts.schema.ParseErrorOps RefinementError
+ * @tsplus location "@fncts/schema/ParseError"
+ */
+export declare function refinementError(ast: Refinement, actual: unknown, kind: "From" | "Predicate", errors: Vector<ParseError>): ParseError;
+/**
+ * @tsplus companion fncts.schema.ParseError.TransformationError
+ */
+export declare class TransformationError {
+    readonly ast: Transform;
+    readonly actual: unknown;
+    readonly kind: "Encoded" | "Transformation" | "Type";
+    readonly errors: Vector<ParseError>;
+    readonly _tag = ParseErrorTag.Transformation;
+    constructor(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", errors: Vector<ParseError>);
+}
+/**
+ * @tsplus static fncts.schema.ParseError.TransformationError __call
+ * @tsplus static fncts.schema.ParseErrorOps TransformationError
+ * @tsplus location "@fncts/schema/ParseError"
+ */
+export declare function transformationError(ast: Transform, actual: unknown, kind: "Encoded" | "Transformation" | "Type", errors: Vector<ParseError>): ParseError;
 /**
  * @tsplus static fncts.schema.ParseErrorOps format
  * @tsplus location "@fncts/schema/ParseError"

package/ParseFailure.d.ts

@@ -0,0 +1,18 @@
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import { ParseError } from "@fncts/schema/ParseError";
+export declare const ParseFailureTypeId: unique symbol;
+export type ParseFailureTypeId = typeof ParseFailureTypeId;
+/**
+ * @tsplus type fncts.schema.ParseFailure
+ * @tsplus companion fncts.schema.ParseFailureOps
+ */
+export declare class ParseFailure {
+    readonly errors: Vector<ParseError>;
+    readonly [ParseFailureTypeId]: ParseFailureTypeId;
+    constructor(errors: Vector<ParseError>);
+}
+/**
+ * @tsplus static fncts.schema.ParseFailureOps __call
+ * @tsplus location "@fncts/schema/ParseFailure"
+ */
+export declare function make(errors: Vector<ParseError>): ParseFailure;

package/ParseResult.d.ts

@@ -1,11 +1,12 @@
 import { Either } from "@fncts/base/data/Either/definition";
+import { ParseFailure } from "@fncts/schema/ParseFailure";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
 import { ParseError } from "@fncts/schema/ParseError";
 /**
  * @tsplus type fncts.schema.ParseResult
  * @tsplus companion fncts.schema.ParseResultOps
  */
-export interface ParseResult<A> extends Either<Vector<ParseError>, A> {
+export interface ParseResult<A> extends Either<ParseFailure, A> {
 }
 /**
  * @tsplus static fncts.schema.ParseResultOps succeed

package/Parser/api.d.ts

@@ -28,12 +28,6 @@ export declare function encode<A>(schema: Schema<A>): <A>(input: A, options?: Pa
  * @tsplus location "@fncts/schema/Parser/api"
  */
 export declare function encodeMaybe<A>(schema: Schema<A>): <A>(input: A, options?: ParseOptions) => Maybe<unknown>;
-/**
- * @tsplus getter fncts.schema.Schema is
- * @tsplus getter fncts.schema.Parser is
- * @tsplus location "@fncts/schema/Parser/api"
- */
-export declare function is<A>(schema: Schema<A>): (input: unknown, options?: ParseOptions) => input is A;
 /**
  * @tsplus getter fncts.schema.Schema asserts
  * @tsplus getter fncts.schema.Parser asserts

package/Parser/interpreter.d.ts

@@ -2,5 +2,4 @@ import { AST } from "@fncts/schema/AST";
 import { Parser } from "@fncts/schema/Parser/definition";
 import { ParseError } from "@fncts/schema/ParseError";
 import { ParseResult } from "@fncts/schema/ParseResult";
-import { Vector } from "@fncts/base/collection/immutable/Vector";
-export declare function parserFor(ast: AST): Parser<any>;
+export declare function parserFor(ast: AST, isDecoding: boolean): Parser<any>;

package/Show.d.ts

@@ -1,6 +1,6 @@
-import { Schema } from "@fncts/schema/Schema/definition";
 import { AST } from "@fncts/schema/AST";
 import { Eval } from "@fncts/base/control/Eval/definition";
+import { Schema } from "@fncts/schema/Schema/definition";
 /**
  * @tsplus getter fncts.schema.Schema show
  * @tsplus location "@fncts/schema/Show"

package/_cjs/AST.cjs

@@ -15,14 +15,19 @@ exports.createIndexSignature = void 0;
 exports.createKey = createKey;
 exports.createPropertySignature = exports.createLiteral = exports.createLazy = void 0;
 exports.createRecord = createRecord;
-exports.createUniqueSymbol = exports.createUnion = exports.createTypeLiteral = exports.createTuple = exports.createTransform = exports.createTemplateLiteral = exports.createRefinement = void 0;
+exports.createTemplateLiteral = exports.createRefinement = void 0;
+exports.createTransform = createTransform;
+exports.createUniqueSymbol = exports.createUnion = exports.createTypeLiteral = exports.createTuple = void 0;
 exports.createValidation = createValidation;
 exports.getAnnotations = getAnnotations;
 exports.getCardinality = getCardinality;
 exports.getCompiler = getCompiler;
 exports.getFrom = void 0;
+exports.getLiterals = getLiterals;
 exports.getParameter = getParameter;
-exports.getTo = exports.getPropertySignatures = void 0;
+exports.getPropertySignatures = void 0;
+exports.getSearchTree = getSearchTree;
+exports.getTo = void 0;
 exports.getWeight = getWeight;
 exports.isBigIntKeyword = isBigIntKeyword;
 exports.isBooleanKeyword = isBooleanKeyword;
@@ -39,18 +44,19 @@ exports.objectKeyword = exports.numberKeyword = exports.neverKeyword = exports.k
 exports.omit = omit;
 exports.partial = void 0;
 exports.pick = pick;
-exports.reverse = void 0;
 exports.setAnnotation = setAnnotation;
-exports.voidKeyword = exports.unknownKeyword = exports.undefinedKeyword = exports.symbolKeyword = exports.stringKeyword = void 0;
+exports.voidKeyword = exports.unknownRecord = exports.unknownKeyword = exports.unknownArray = exports.undefinedKeyword = exports.symbolKeyword = exports.stringKeyword = void 0;
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/schema/ASTAnnotation"));
 var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/api"));
-var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/number/instances"));
-var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Ord/api/contramap"));
-var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
-var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
-var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
-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/api"));
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/schema/ParseResult"));
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/schema/ParseError"));
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/number/instances"));
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Ord/api/contramap"));
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Vector/internal"));
+var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
 var _Showable = /*#__PURE__*/require("@fncts/base/data/Showable");
 var _utils = /*#__PURE__*/require("@fncts/schema/utils");
 var _ASTAnnotationMap = /*#__PURE__*/require("./ASTAnnotationMap.cjs");
@@ -75,13 +81,11 @@ const createTypeLiteral = exports.createTypeLiteral = createTypeLiteral_1;
 const createUnion = exports.createUnion = createUnion_1;
 const createLazy = exports.createLazy = createLazy_1;
 const createRefinement = exports.createRefinement = createRefinement_1;
-const createTransform = exports.createTransform = createTransform_1;
 const getPropertySignatures = exports.getPropertySignatures = getPropertySignatures_1;
 const keysOf = exports.keysOf = keysOf_1;
 const partial = exports.partial = partial_1;
 const getFrom = exports.getFrom = getFrom_1;
 const getTo = exports.getTo = getTo_1;
-const reverse = exports.reverse = reverse_1;
 const ASTTypeId = exports.ASTTypeId = /*#__PURE__*/Symbol.for("fncts.schema.AST");
 class Annotated {
   constructor() {
@@ -269,7 +273,8 @@ class UnknownKeyword extends AST {
  * @tsplus static fncts.schema.ASTOps unknownKeyword
  */
 exports.UnknownKeyword = UnknownKeyword;
-const unknownKeyword = exports.unknownKeyword = /*#__PURE__*/new UnknownKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "unknown"));
+const unknownKeyword_1 = /*#__PURE__*/new UnknownKeyword( /*#__PURE__*/_ASTAnnotationMap.ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "unknown"));
+const unknownKeyword = exports.unknownKeyword = unknownKeyword_1;
 /*
  * AnyKeyword
  */
@@ -527,6 +532,10 @@ exports.Tuple = Tuple;
 function createTuple_1(elements, rest, isReadonly, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
   return new Tuple(elements, rest, isReadonly, annotations);
 }
+/**
+ * @tsplus static fncts.schema.ASTOps unknownArray
+ */
+const unknownArray = exports.unknownArray = /*#__PURE__*/createTuple_1( /*#__PURE__*/tsplus_module_2.empty(), /*#__PURE__*/tsplus_module_3.just( /*#__PURE__*/tsplus_module_2.vector(unknownKeyword_1), fileName_1 + ":629:65"), true);
 /*
  * PropertySignature
  */
@@ -597,6 +606,10 @@ function isTypeLiteral(self) {
 function createTypeLiteral_1(propertySignatures, indexSignatures, annotations) {
   return new TypeLiteral(propertySignatures, indexSignatures, annotations);
 }
+/**
+ * @tsplus static fncts.schema.ASTOps unknownRecord
+ */
+const unknownRecord = exports.unknownRecord = /*#__PURE__*/createTypeLiteral_1( /*#__PURE__*/tsplus_module_2.empty(), /*#__PURE__*/tsplus_module_2.vector( /*#__PURE__*/createIndexSignature_1(stringKeyword_1, unknownKeyword_1, true), /*#__PURE__*/createIndexSignature_1(symbolKeyword_1, unknownKeyword_1, true)));
 /*
  * Union
  */
@@ -665,24 +678,26 @@ function isLazy(self) {
  * Refinement
  */
 class Refinement extends AST {
-  constructor(from, decode, isReversed, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  constructor(from, predicate, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
     super();
     this.from = from;
-    this.decode = decode;
-    this.isReversed = isReversed;
+    this.predicate = predicate;
     this.annotations = annotations;
     this._tag = 20 /* ASTTag.Refinement */;
   }
+  decode(input, options) {
+    return this.predicate(input) ? tsplus_module_4.succeed(input) : tsplus_module_4.fail(tsplus_module_5.typeError(this, input));
+  }
   clone(newProperties) {
-    return new Refinement(newProperties.from ?? this.from, newProperties.decode ?? this.decode, newProperties.isReversed ?? this.isReversed, newProperties.annotations ?? this.annotations);
+    return new Refinement(newProperties.from ?? this.from, newProperties.predicate ?? this.predicate, newProperties.annotations ?? this.annotations);
   }
 }
 /**
  * @tsplus static fncts.schema.ASTOps createRefinement
  */
 exports.Refinement = Refinement;
-function createRefinement_1(from, decode, isReversed, annotations) {
-  return new Refinement(from, decode, isReversed, annotations);
+function createRefinement_1(from, predicate, annotations) {
+  return new Refinement(from, predicate, annotations);
 }
 function isRefinement(self) {
   void 0;
@@ -692,26 +707,25 @@ function isRefinement(self) {
  * Transform
  */
 class Transform extends AST {
-  constructor(from, to, decode, encode, isReversed, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
+  constructor(from, to, decode, encode, annotations = _ASTAnnotationMap.ASTAnnotationMap.empty) {
     super();
     this.from = from;
     this.to = to;
     this.decode = decode;
     this.encode = encode;
-    this.isReversed = isReversed;
     this.annotations = annotations;
     this._tag = 21 /* ASTTag.Transform */;
   }
   clone(newProperties) {
-    return new Transform(newProperties.from ?? this.from, newProperties.to ?? this.to, newProperties.decode ?? this.decode, newProperties.encode ?? this.encode, newProperties.isReversed ?? this.isReversed, newProperties.annotations ?? this.annotations);
+    return new Transform(newProperties.from ?? this.from, newProperties.to ?? this.to, newProperties.decode ?? this.decode, newProperties.encode ?? this.encode, newProperties.annotations ?? this.annotations);
   }
 }
 /**
  * @tsplus static fncts.schema.ASTOps createTransform
  */
 exports.Transform = Transform;
-function createTransform_1(from, to, decode, encode, isReversed, annotations) {
-  return new Transform(from, getTo_1(to), decode, encode, isReversed, annotations);
+function createTransform(from, to, decode, encode, annotations) {
+  return new Transform(from, getTo_1(to), decode, encode, annotations);
 }
 /*
  * Validation
@@ -781,9 +795,9 @@ function getCardinality(ast) {
   }
 }
 function sortByAscendingCardinality(types) {
-  return tsplus_module_2.sort(tsplus_module_4.contramap(({
+  return tsplus_module_2.sort(tsplus_module_7.contramap(({
     type
-  }) => getCardinality(type))(tsplus_module_3.Ord))(types);
+  }) => getCardinality(type))(tsplus_module_6.Ord))(types);
 }
 function getWeight(ast) {
   void 0;
@@ -791,7 +805,7 @@ function getWeight(ast) {
     case 0 /* ASTTag.Declaration */:
       return getWeight(ast.type);
     case 16 /* ASTTag.Tuple */:
-      return ast.elements.length + (tsplus_module_5.isJust(ast.rest) ? ast.rest.value.length : 0);
+      return ast.elements.length + (tsplus_module_8.isJust(ast.rest) ? ast.rest.value.length : 0);
     case 17 /* ASTTag.TypeLiteral */:
       return ast.propertySignatures.length + ast.indexSignatures.length;
     case 18 /* ASTTag.Union */:
@@ -807,7 +821,7 @@ function getWeight(ast) {
   }
 }
 function sortByDescendingWeight(types) {
-  return tsplus_module_2.sort(tsplus_module_4.contramap(getWeight)(tsplus_module_3.Ord))(types);
+  return tsplus_module_2.sort(tsplus_module_7.contramap(getWeight)(tsplus_module_6.Ord))(types);
 }
 function unify(candidates) {
   let out = tsplus_module_2.flatMap(ast => {
@@ -857,10 +871,10 @@ function setAnnotation(annotation, value) {
  */
 function appendRestElement(restElement) {
   return self => {
-    if (tsplus_module_5.isJust(self.rest)) {
+    if (tsplus_module_8.isJust(self.rest)) {
       throw new Error("A rest element cannot follow another rest element. ts(1265)");
     }
-    return createTuple_1(self.elements, tsplus_module_6.just(tsplus_module_2.vector(restElement), fileName_1 + ":1048:43"), self.isReadonly, self.annotations);
+    return createTuple_1(self.elements, tsplus_module_3.just(tsplus_module_2.vector(restElement), fileName_1 + ":1062:43"), self.isReadonly, self.annotations);
   };
 }
 /**
@@ -871,11 +885,11 @@ function appendElement(element) {
     if (tsplus_module_2.some(e => e.isOptional)(self.elements) && !element.isOptional) {
       throw new Error("A required element cannot follow an optional element. ts(1257)");
     }
-    return tsplus_module_7.match(() => createTuple_1(tsplus_module_2.append(element)(self.elements), tsplus_module_6.nothing(fileName_1 + ":1061:63"), self.isReadonly, self.annotations), rest => {
+    return tsplus_module_9.match(() => createTuple_1(tsplus_module_2.append(element)(self.elements), tsplus_module_3.nothing(fileName_1 + ":1075:63"), self.isReadonly, self.annotations), rest => {
       if (element.isOptional) {
         throw new Error("A required element cannot follow an optional element. ts(1257)");
       }
-      return createTuple_1(self.elements, tsplus_module_6.just(tsplus_module_2.append(element.type)(rest), fileName_1 + ":1066:47"), self.isReadonly, self.annotations);
+      return createTuple_1(self.elements, tsplus_module_3.just(tsplus_module_2.append(element.type)(rest), fileName_1 + ":1080:47"), self.isReadonly, self.annotations);
     })(self.rest);
   };
 }
@@ -900,9 +914,9 @@ function getPropertySignatures_1(self) {
         }) => {
           if (tsplus_module_2.every(ps => tsplus_module_2.some(p => p.name === name)(ps))(propertySignatures)) {
             const members = tsplus_module_2.flatMap(ps => tsplus_module_2.filter(p => p.name === name)(ps))(propertySignatures);
-            return tsplus_module_6.just(createPropertySignature_1(name, createUnion_1(tsplus_module_2.map(p => p.type)(members)), tsplus_module_2.some(p => p.isOptional)(members), tsplus_module_2.some(p => p.isReadonly)(members)), fileName_1 + ":1093:22");
+            return tsplus_module_3.just(createPropertySignature_1(name, createUnion_1(tsplus_module_2.map(p => p.type)(members)), tsplus_module_2.some(p => p.isOptional)(members), tsplus_module_2.some(p => p.isReadonly)(members)), fileName_1 + ":1107:22");
           }
-          return tsplus_module_6.nothing(fileName_1 + ":1102:23");
+          return tsplus_module_3.nothing(fileName_1 + ":1116:23");
         })(tsplus_module_2.unsafeGet(0)(propertySignatures));
       }
     case 19 /* ASTTag.Lazy */:
@@ -966,15 +980,15 @@ function createRecord(key, value, isReadonly) {
       case 12 /* ASTTag.SymbolKeyword */:
       case 15 /* ASTTag.TemplateLiteral */:
       case 20 /* ASTTag.Refinement */:
-        tsplus_module_8.push(createIndexSignature_1(key, value, isReadonly))(indexSignatures);
+        tsplus_module_10.push(createIndexSignature_1(key, value, isReadonly))(indexSignatures);
         break;
       case 1 /* ASTTag.Literal */:
         if (typeof key.literal === "string" || typeof key.literal === "number") {
-          tsplus_module_8.push(createPropertySignature_1(key.literal, value, false, isReadonly))(propertySignatures);
+          tsplus_module_10.push(createPropertySignature_1(key.literal, value, false, isReadonly))(propertySignatures);
         }
         break;
       case 2 /* ASTTag.UniqueSymbol */:
-        tsplus_module_8.push(createPropertySignature_1(key.symbol, value, false, isReadonly))(propertySignatures);
+        tsplus_module_10.push(createPropertySignature_1(key.symbol, value, false, isReadonly))(propertySignatures);
         break;
       case 18 /* ASTTag.Union */:
         tsplus_module_2.forEach(go)(key.types);
@@ -1011,7 +1025,7 @@ function partial_1(self) {
     case 0 /* ASTTag.Declaration */:
       return partial_1(self.type);
     case 16 /* ASTTag.Tuple */:
-      return createTuple_1(tsplus_module_2.map(e => createElement_1(e.type, true))(self.elements), tsplus_module_9.map(rest => tsplus_module_2.vector(createUnion_1(tsplus_module_2.append(undefinedKeyword_1)(rest))))(self.rest), self.isReadonly);
+      return createTuple_1(tsplus_module_2.map(e => createElement_1(e.type, true))(self.elements), tsplus_module_11.map(rest => tsplus_module_2.vector(createUnion_1(tsplus_module_2.append(undefinedKeyword_1)(rest))))(self.rest), self.isReadonly);
     case 17 /* ASTTag.TypeLiteral */:
       return createTypeLiteral_1(tsplus_module_2.map(f => createPropertySignature_1(f.name, f.type, true, f.isReadonly, f.annotations))(self.propertySignatures), self.indexSignatures);
     case 18 /* ASTTag.Union */:
@@ -1041,7 +1055,7 @@ function getFrom_1(ast) {
     case 0 /* ASTTag.Declaration */:
       return createDeclaration_1(tsplus_module_2.map(getFrom_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
     case 16 /* ASTTag.Tuple */:
-      return createTuple_1(tsplus_module_2.map(element => createElement_1(getFrom_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(getFrom_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
+      return createTuple_1(tsplus_module_2.map(element => createElement_1(getFrom_1(element.type), element.isOptional))(ast.elements), tsplus_module_11.map(restElement => tsplus_module_2.map(getFrom_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
     case 17 /* ASTTag.TypeLiteral */:
       return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, getFrom_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, getFrom_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
     case 18 /* ASTTag.Union */:
@@ -1063,7 +1077,7 @@ function getTo_1(ast) {
     case 0 /* ASTTag.Declaration */:
       return createDeclaration_1(tsplus_module_2.map(getTo_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
     case 16 /* ASTTag.Tuple */:
-      return createTuple_1(tsplus_module_2.map(element => createElement_1(getTo_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(getTo_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
+      return createTuple_1(tsplus_module_2.map(element => createElement_1(getTo_1(element.type), element.isOptional))(ast.elements), tsplus_module_11.map(restElement => tsplus_module_2.map(getTo_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
     case 17 /* ASTTag.TypeLiteral */:
       return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, getTo_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, getTo_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
     case 18 /* ASTTag.Union */:
@@ -1071,35 +1085,12 @@ function getTo_1(ast) {
     case 19 /* ASTTag.Lazy */:
       return createLazy_1(() => getTo_1(ast.getAST()), ast.annotations);
     case 20 /* ASTTag.Refinement */:
-      return createRefinement_1(getTo_1(ast.from), ast.decode, false, ast.annotations);
+      return createRefinement_1(getTo_1(ast.from), ast.predicate, ast.annotations);
     case 21 /* ASTTag.Transform */:
       return getTo_1(ast.to);
   }
   return ast;
 }
-/**
- * @tsplus getter fncts.schema.AST reverse
- */
-function reverse_1(ast) {
-  void 0;
-  switch (ast._tag) {
-    case 0 /* ASTTag.Declaration */:
-      return createDeclaration_1(tsplus_module_2.map(reverse_1)(ast.typeParameters), ast.type, ast.decode, ast.annotations);
-    case 16 /* ASTTag.Tuple */:
-      return createTuple_1(tsplus_module_2.map(element => createElement_1(reverse_1(element.type), element.isOptional))(ast.elements), tsplus_module_9.map(restElement => tsplus_module_2.map(reverse_1)(restElement))(ast.rest), ast.isReadonly, ast.annotations);
-    case 17 /* ASTTag.TypeLiteral */:
-      return createTypeLiteral_1(tsplus_module_2.map(ps => createPropertySignature_1(ps.name, reverse_1(ps.type), ps.isOptional, ps.isReadonly, ps.annotations))(ast.propertySignatures), tsplus_module_2.map(is => createIndexSignature_1(is.parameter, reverse_1(is.type), is.isReadonly))(ast.indexSignatures), ast.annotations);
-    case 18 /* ASTTag.Union */:
-      return createUnion_1(tsplus_module_2.map(reverse_1)(ast.types), ast.annotations);
-    case 19 /* ASTTag.Lazy */:
-      return createLazy_1(() => reverse_1(ast.getAST()), ast.annotations);
-    case 20 /* ASTTag.Refinement */:
-      return createRefinement_1(ast.from, ast.decode, !ast.isReversed, ast.annotations);
-    case 21 /* ASTTag.Transform */:
-      return createTransform_1(reverse_1(ast.from), ast.to, ast.decode, ast.encode, !ast.isReversed, ast.annotations);
-  }
-  return ast;
-}
 /**
  * @tsplus static fncts.schema.AST getCompiler
  */
@@ -1110,4 +1101,63 @@ function getCompiler(match) {
   });
   return compile;
 }
+function getLiterals(ast, isDecoding) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return getLiterals(ast.type, isDecoding);
+    case 17 /* ASTTag.TypeLiteral */:
+      {
+        const out = [];
+        for (let i = 0; i < ast.propertySignatures.length; i++) {
+          const propertySignature = tsplus_module_2.unsafeGet(i)(ast.propertySignatures);
+          if (isLiteral_1(propertySignature.type) && !propertySignature.isOptional) {
+            out.push([propertySignature.name, propertySignature.type]);
+          }
+        }
+        return out;
+      }
+    case 20 /* ASTTag.Refinement */:
+      return getLiterals(ast.from, isDecoding);
+    case 21 /* ASTTag.Transform */:
+      return getLiterals(isDecoding ? ast.from : ast.to, isDecoding);
+  }
+  return [];
+}
+function getSearchTree(members, isDecoding) {
+  const keys = {};
+  const otherwise = [];
+  for (let i = 0; i < members.length; i++) {
+    const member = tsplus_module_2.unsafeGet(i)(members);
+    const tags = getLiterals(member, isDecoding);
+    if (tags.length > 0) {
+      for (let j = 0; j < tags.length; j++) {
+        const [key, literal] = tags[j];
+        const hash = String(literal.literal);
+        keys[key] || (keys[key] = {
+          buckets: {},
+          ast: neverKeyword_1
+        });
+        const buckets = keys[key].buckets;
+        if (Object.prototype.hasOwnProperty.call(buckets, hash)) {
+          if (j < tags.length - 1) {
+            continue;
+          }
+          buckets[hash].push(member);
+          keys[key].ast = createUnion_1(tsplus_module_2.vector(keys[key].ast, literal));
+        } else {
+          buckets[hash] = [member];
+          keys[key].ast = createUnion_1(tsplus_module_2.vector(keys[key].ast, literal));
+          break;
+        }
+      }
+    } else {
+      otherwise.push(member);
+    }
+  }
+  return {
+    keys,
+    otherwise
+  };
+}
 //# sourceMappingURL=AST.cjs.map