@fncts/schema 0.0.5 → 0.0.6

package/_mjs/AST.mjs

@@ -0,0 +1,1060 @@
+var _a;
+import * as tsplus_module_1 from "@fncts/schema/ASTAnnotation";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/Vector/api";
+import * as tsplus_module_3 from "@fncts/base/data/number/instances";
+import * as tsplus_module_4 from "@fncts/base/data/Ord/api/contramap";
+import * as tsplus_module_5 from "@fncts/base/data/Maybe/definition";
+import * as tsplus_module_6 from "@fncts/base/data/Maybe/constructors";
+import * as tsplus_module_7 from "@fncts/base/data/Maybe/destructors";
+import * as tsplus_module_8 from "@fncts/base/collection/immutable/Vector/internal";
+import * as tsplus_module_9 from "@fncts/base/data/Maybe/api";
+export const createDeclaration = createDeclaration_1;
+export const createLiteral = createLiteral_1;
+export const isLiteral = isLiteral_1;
+export const createUniqueSymbol = createUniqueSymbol_1;
+export const isUniqueSymbol = isUniqueSymbol_1;
+export const isStringKeyword = isStringKeyword_1;
+export const isNumberKeyword = isNumberKeyword_1;
+export const isSymbolKeyword = isSymbolKeyword_1;
+export const createTemplateLiteral = createTemplateLiteral_1;
+export const createElement = createElement_1;
+export const createTuple = createTuple_1;
+export const createPropertySignature = createPropertySignature_1;
+export const createIndexSignature = createIndexSignature_1;
+export const createTypeLiteral = createTypeLiteral_1;
+export const createUnion = createUnion_1;
+export const createLazy = createLazy_1;
+export const createRefinement = createRefinement_1;
+export const createTransform = createTransform_1;
+export const getPropertySignatures = getPropertySignatures_1;
+export const keysOf = keysOf_1;
+export const partial = partial_1;
+export const getFrom = getFrom_1;
+export const getTo = getTo_1;
+export const reverse = reverse_1;
+import { show } from "@fncts/base/data/Showable";
+import { memoize } from "@fncts/schema/utils";
+import { ASTAnnotationMap } from "./ASTAnnotationMap.mjs";
+export const ASTTypeId = /*#__PURE__*/Symbol.for("fncts.schema.AST");
+export class Annotated {
+  constructor() {
+    this.annotations = ASTAnnotationMap.empty;
+  }
+}
+/**
+ * @tsplus type fncts.schema.AST
+ * @tsplus companion fncts.schema.ASTOps
+ */
+export class AST extends Annotated {
+  constructor() {
+    super(...arguments);
+    this[_a] = ASTTypeId;
+  }
+}
+_a = ASTTypeId;
+/**
+ * @tsplus static fncts.schema.ASTOps concrete
+ * @tsplus macro remove
+ */
+export function concrete(_) {
+  //
+}
+export function getAnnotations(key) {
+  return self => {
+    return self.annotations.get(key);
+  };
+}
+/*
+ * Declaration
+ */
+export class Declaration extends AST {
+  constructor(typeParameters, type, decode, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.typeParameters = typeParameters;
+    this.type = type;
+    this.decode = decode;
+    this.annotations = annotations;
+    this._tag = 0 /* ASTTag.Declaration */;
+  }
+
+  clone(newProperties) {
+    return new Declaration(newProperties.typeParameters ?? this.typeParameters, newProperties.type ?? this.type, newProperties.decode ?? this.decode, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createDeclaration
+ */
+function createDeclaration_1(typeParameters, type, decode, annotations = ASTAnnotationMap.empty) {
+  return new Declaration(typeParameters, type, decode, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isDeclaration
+ */
+export function isDeclaration(self) {
+  void 0;
+  return self._tag === 0 /* ASTTag.Declaration */;
+}
+
+export class Literal extends AST {
+  constructor(literal, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.literal = literal;
+    this.annotations = annotations;
+    this._tag = 1 /* ASTTag.Literal */;
+  }
+
+  clone(newProperties) {
+    return new Literal(newProperties.literal ?? this.literal, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLiteral
+ */
+function createLiteral_1(literal, annotations = ASTAnnotationMap.empty) {
+  return new Literal(literal, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isLiteral
+ */
+function isLiteral_1(self) {
+  void 0;
+  return self._tag === 1 /* ASTTag.Literal */;
+}
+/*
+ * UniqueSymbol
+ */
+export class UniqueSymbol extends AST {
+  constructor(symbol, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.symbol = symbol;
+    this.annotations = annotations;
+    this._tag = 2 /* ASTTag.UniqueSymbol */;
+  }
+
+  clone(newProperties) {
+    return new UniqueSymbol(newProperties.symbol ?? this.symbol, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createUniqueSymbol
+ */
+function createUniqueSymbol_1(symbol, annotations = ASTAnnotationMap.empty) {
+  return new UniqueSymbol(symbol, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isUniqueSymbol
+ */
+function isUniqueSymbol_1(self) {
+  void 0;
+  return self._tag === 2 /* ASTTag.UniqueSymbol */;
+}
+/*
+ * UndefinedKeyword
+ */
+export class UndefinedKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 3 /* ASTTag.UndefinedKeyword */;
+  }
+
+  clone(newProperties) {
+    return new UndefinedKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps undefinedKeyword
+ */
+const undefinedKeyword_1 = /*#__PURE__*/new UndefinedKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "undefined"));
+export const undefinedKeyword = undefinedKeyword_1;
+/*
+ * VoidKeyword
+ */
+export class VoidKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 4 /* ASTTag.VoidKeyword */;
+  }
+
+  clone(newProperties) {
+    return new VoidKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps voidKeyword
+ */
+export const voidKeyword = /*#__PURE__*/new VoidKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "void"));
+/*
+ * NeverKeyword
+ */
+export class NeverKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 5 /* ASTTag.NeverKeyword */;
+  }
+
+  clone(newProperties) {
+    return new NeverKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps neverKeyword
+ */
+const neverKeyword_1 = /*#__PURE__*/new NeverKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "never"));
+export const neverKeyword = neverKeyword_1;
+/*
+ * UnknownKeyword
+ */
+export class UnknownKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 6 /* ASTTag.UnknownKeyword */;
+  }
+
+  clone(newProperties) {
+    return new UnknownKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps unknownKeyword
+ */
+export const unknownKeyword = /*#__PURE__*/new UnknownKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "unknown"));
+/*
+ * AnyKeyword
+ */
+export class AnyKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 7 /* ASTTag.AnyKeyword */;
+  }
+
+  clone(newProperties) {
+    return new AnyKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps anyKeyword
+ */
+export const anyKeyword = /*#__PURE__*/new AnyKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "any"));
+/*
+ * StringKeyword
+ */
+export class StringKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 8 /* ASTTag.StringKeyword */;
+  }
+
+  clone(newProperties) {
+    return new StringKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps stringKeyword
+ */
+const stringKeyword_1 = /*#__PURE__*/new StringKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "string"));
+export const stringKeyword = stringKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isStringKeyword
+ */
+function isStringKeyword_1(self) {
+  void 0;
+  return self._tag === 8 /* ASTTag.StringKeyword */;
+}
+/*
+ * NumberKeyword
+ */
+export class NumberKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 9 /* ASTTag.NumberKeyword */;
+  }
+
+  clone(newProperties) {
+    return new NumberKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps numberKeyword
+ */
+const numberKeyword_1 = /*#__PURE__*/new NumberKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "number"));
+export const numberKeyword = numberKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isNumberKeyword
+ */
+function isNumberKeyword_1(self) {
+  void 0;
+  return self._tag === 9 /* ASTTag.NumberKeyword */;
+}
+/*
+ * BooleanKeyword
+ */
+export class BooleanKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 10 /* ASTTag.BooleanKeyword */;
+  }
+
+  clone(newProperties) {
+    return new BooleanKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps booleanKeyword
+ */
+export const booleanKeyword = /*#__PURE__*/new BooleanKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "boolean"));
+/**
+ * @tsplus fluent fncts.schema.AST isBooleanKeyword
+ */
+export function isBooleanKeyword(self) {
+  void 0;
+  return self._tag === 10 /* ASTTag.BooleanKeyword */;
+}
+/*
+ * BigIntKeyword
+ */
+export class BigIntKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 11 /* ASTTag.BigIntKeyword */;
+  }
+
+  clone(newProperties) {
+    return new BigIntKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps bigIntKeyword
+ */
+export const bigIntKeyword = /*#__PURE__*/new BigIntKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "bigint"));
+/**
+ * @tsplus fluent fncts.schema.AST isBigIntKeyword
+ */
+export function isBigIntKeyword(self) {
+  void 0;
+  return self._tag === 11 /* ASTTag.BigIntKeyword */;
+}
+/*
+ * SymbolKeyword
+ */
+export class SymbolKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 12 /* ASTTag.SymbolKeyword */;
+  }
+
+  clone(newProperties) {
+    return new SymbolKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps symbolKeyword
+ */
+const symbolKeyword_1 = /*#__PURE__*/new SymbolKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "symbol"));
+export const symbolKeyword = symbolKeyword_1;
+/**
+ * @tsplus fluent fncts.schema.AST isSymbolKeyword
+ */
+function isSymbolKeyword_1(self) {
+  void 0;
+  return self._tag === 12 /* ASTTag.SymbolKeyword */;
+}
+/*
+ * ObjectKeyword
+ */
+export class ObjectKeyword extends AST {
+  constructor(annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 13 /* ASTTag.ObjectKeyword */;
+  }
+
+  clone(newProperties) {
+    return new ObjectKeyword(newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps objectKeyword
+ */
+export const objectKeyword = /*#__PURE__*/new ObjectKeyword( /*#__PURE__*/ASTAnnotationMap.empty.annotate(tsplus_module_1.Title, "object"));
+/*
+ * Enum
+ */
+export class Enum extends AST {
+  constructor(enums, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.enums = enums;
+    this.annotations = annotations;
+    this._tag = 14 /* ASTTag.Enum */;
+  }
+
+  clone(newProperties) {
+    return new Enum(newProperties.enums ?? this.enums, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createEnum
+ */
+export function createEnum(enums, annotations = ASTAnnotationMap.empty) {
+  return new Enum(enums, annotations);
+}
+export class TemplateLiteralSpan {
+  constructor(type, literal) {
+    this.type = type;
+    this.literal = literal;
+  }
+}
+/*
+ * TemplateLiteral
+ */
+export class TemplateLiteral extends AST {
+  constructor(head, spans, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.head = head;
+    this.spans = spans;
+    this.annotations = annotations;
+    this._tag = 15 /* ASTTag.TemplateLiteral */;
+  }
+
+  clone(newProperties) {
+    return createTemplateLiteral_1(newProperties.head ?? this.head, newProperties.spans ?? this.spans, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTemplateLiteral
+ */
+function createTemplateLiteral_1(head, spans, annotations = ASTAnnotationMap.empty) {
+  if (tsplus_module_2.isNonEmpty(spans)) {
+    return new TemplateLiteral(head, spans, annotations);
+  } else {
+    return createLiteral_1(head, annotations);
+  }
+}
+/*
+ * Element
+ */
+export class Element {
+  constructor(type, isOptional) {
+    this.type = type;
+    this.isOptional = isOptional;
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createElement
+ */
+function createElement_1(type, isOptional) {
+  return new Element(type, isOptional);
+}
+/*
+ * Tuple
+ */
+export class Tuple extends AST {
+  constructor(elements, rest, isReadonly, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.elements = elements;
+    this.rest = rest;
+    this.isReadonly = isReadonly;
+    this.annotations = annotations;
+    this._tag = 16 /* ASTTag.Tuple */;
+  }
+
+  clone(newProperties) {
+    return new Tuple(newProperties.elements ?? this.elements, newProperties.rest ?? this.rest, newProperties.isReadonly ?? this.isReadonly, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTuple
+ */
+function createTuple_1(elements, rest, isReadonly, annotations = ASTAnnotationMap.empty) {
+  return new Tuple(elements, rest, isReadonly, annotations);
+}
+/*
+ * PropertySignature
+ */
+export class PropertySignature extends AST {
+  constructor(name, type, isOptional, isReadonly, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.name = name;
+    this.type = type;
+    this.isOptional = isOptional;
+    this.isReadonly = isReadonly;
+    this.annotations = annotations;
+  }
+  clone(newProperties) {
+    return new PropertySignature(newProperties.name ?? this.name, newProperties.type ?? this.type, newProperties.isOptional ?? this.isOptional, newProperties.isReadonly ?? this.isReadonly, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createPropertySignature
+ */
+function createPropertySignature_1(name, type, isOptional, isReadonly, annotations = ASTAnnotationMap.empty) {
+  return new PropertySignature(name, type, isOptional, isReadonly, annotations);
+}
+/*
+ * IndexSignature
+ */
+export class IndexSignature {
+  constructor(parameter, type, isReadonly) {
+    this.parameter = parameter;
+    this.type = type;
+    this.isReadonly = isReadonly;
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createIndexSignature
+ */
+function createIndexSignature_1(parameter, type, isReadonly) {
+  return new IndexSignature(parameter, type, isReadonly);
+}
+/*
+ * TypeLiteral
+ */
+export class TypeLiteral extends AST {
+  constructor(propertySignatures, indexSignatures, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.annotations = annotations;
+    this._tag = 17 /* ASTTag.TypeLiteral */;
+    this.propertySignatures = sortByAscendingCardinality(propertySignatures);
+    this.indexSignatures = sortByAscendingCardinality(indexSignatures);
+  }
+  clone(newProperties) {
+    return new TypeLiteral(newProperties.propertySignatures ?? this.propertySignatures, newProperties.indexSignatures ?? this.indexSignatures, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps isTypeLiteral
+ * @tsplus fluent fncts.schema.AST isTypeLiteral
+ */
+export function isTypeLiteral(self) {
+  void 0;
+  return self._tag === 17 /* ASTTag.TypeLiteral */;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTypeLiteral
+ */
+function createTypeLiteral_1(propertySignatures, indexSignatures, annotations) {
+  return new TypeLiteral(propertySignatures, indexSignatures, annotations);
+}
+/*
+ * Union
+ */
+export class Union extends AST {
+  constructor(types, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.types = types;
+    this.annotations = annotations;
+    this._tag = 18 /* ASTTag.Union */;
+  }
+
+  clone(newProperties) {
+    return createUnion_1(newProperties.types ?? this.types, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus fluent fncts.schema.AST isUnion
+ */
+export function isUnion(self) {
+  void 0;
+  return self._tag === 18 /* ASTTag.Union */;
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createUnion
+ */
+function createUnion_1(candidates, annotations = ASTAnnotationMap.empty) {
+  const types = unify(candidates);
+  switch (types.length) {
+    case 0:
+      return neverKeyword_1;
+    case 1:
+      return tsplus_module_2.unsafeGet(0)(types);
+    default:
+      return new Union(sortByDescendingWeight(types), annotations);
+  }
+}
+/*
+ * Lazy
+ */
+export class Lazy extends AST {
+  constructor(getAST, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.getAST = getAST;
+    this.annotations = annotations;
+    this._tag = 19 /* ASTTag.Lazy */;
+  }
+
+  clone(newProperties) {
+    return new Lazy(newProperties.getAST ?? this.getAST, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createLazy
+ */
+function createLazy_1(getAST, annotations) {
+  return new Lazy(getAST, annotations);
+}
+/**
+ * @tsplus fluent fncts.schema.AST isLazy
+ */
+export function isLazy(self) {
+  void 0;
+  return self._tag === 19 /* ASTTag.Lazy */;
+}
+/*
+ * Refinement
+ */
+export class Refinement extends AST {
+  constructor(from, decode, isReversed, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.from = from;
+    this.decode = decode;
+    this.isReversed = isReversed;
+    this.annotations = annotations;
+    this._tag = 20 /* ASTTag.Refinement */;
+  }
+
+  clone(newProperties) {
+    return new Refinement(newProperties.from ?? this.from, newProperties.decode ?? this.decode, newProperties.isReversed ?? this.isReversed, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createRefinement
+ */
+function createRefinement_1(from, decode, isReversed, annotations) {
+  return new Refinement(from, decode, isReversed, annotations);
+}
+export function isRefinement(self) {
+  void 0;
+  return self._tag === 20 /* ASTTag.Refinement */;
+}
+/*
+ * Transform
+ */
+export class Transform extends AST {
+  constructor(from, to, decode, encode, isReversed, annotations = 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);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createTransform
+ */
+function createTransform_1(from, to, decode, encode, isReversed, annotations) {
+  return new Transform(from, getTo_1(to), decode, encode, isReversed, annotations);
+}
+/*
+ * Validation
+ */
+export class Validation extends AST {
+  constructor(from, validation, annotations = ASTAnnotationMap.empty) {
+    super();
+    this.from = from;
+    this.validation = validation;
+    this.annotations = annotations;
+    this._tag = 22 /* ASTTag.Validation */;
+  }
+
+  clone(newProperties) {
+    return new Validation(newProperties.from ?? this.from, newProperties.validation ?? this.validation, newProperties.annotations ?? this.annotations);
+  }
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createValidation
+ */
+export function createValidation(from, validation, annotations) {
+  return new Validation(from, validation, annotations);
+}
+/**
+ * @tsplus tailRec
+ */
+export function getCardinality(ast) {
+  var ast_1 = ast;
+  var ast_2 = ast;
+  while (1) {
+    void 0;
+    switch (ast_1._tag) {
+      case 0 /* ASTTag.Declaration */:
+        ast_2 = ast_1.type;
+        ast_1 = ast_2;
+        continue;
+      case 5 /* ASTTag.NeverKeyword */:
+        return 0;
+      case 1 /* ASTTag.Literal */:
+      case 3 /* ASTTag.UndefinedKeyword */:
+      case 4 /* ASTTag.VoidKeyword */:
+      case 2 /* ASTTag.UniqueSymbol */:
+        return 1;
+      case 10 /* ASTTag.BooleanKeyword */:
+        return 2;
+      case 8 /* ASTTag.StringKeyword */:
+      case 9 /* ASTTag.NumberKeyword */:
+      case 11 /* ASTTag.BigIntKeyword */:
+      case 12 /* ASTTag.SymbolKeyword */:
+        return 3;
+      case 13 /* ASTTag.ObjectKeyword */:
+        return 4;
+      case 6 /* ASTTag.UnknownKeyword */:
+      case 7 /* ASTTag.AnyKeyword */:
+        return 6;
+      case 20 /* ASTTag.Refinement */:
+        ast_2 = ast_1.from;
+        ast_1 = ast_2;
+        continue;
+      case 21 /* ASTTag.Transform */:
+        ast_2 = ast_1.to;
+        ast_1 = ast_2;
+        continue;
+      default:
+        return 5;
+    }
+  }
+}
+function sortByAscendingCardinality(types) {
+  return tsplus_module_2.sort(tsplus_module_4.contramap(({
+    type
+  }) => getCardinality(type))(tsplus_module_3.Ord))(types);
+}
+export function getWeight(ast) {
+  void 0;
+  switch (ast._tag) {
+    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);
+    case 17 /* ASTTag.TypeLiteral */:
+      return ast.propertySignatures.length + ast.indexSignatures.length;
+    case 18 /* ASTTag.Union */:
+      return tsplus_module_2.foldLeft(0, (n, member) => n + getWeight(member))(ast.types);
+    case 19 /* ASTTag.Lazy */:
+      return 10;
+    case 20 /* ASTTag.Refinement */:
+      return getWeight(ast.from);
+    case 21 /* ASTTag.Transform */:
+      return getWeight(ast.to);
+    default:
+      return 0;
+  }
+}
+function sortByDescendingWeight(types) {
+  return tsplus_module_2.sort(tsplus_module_4.contramap(getWeight)(tsplus_module_3.Ord))(types);
+}
+function unify(candidates) {
+  let out = tsplus_module_2.flatMap(ast => {
+    void 0;
+    switch (ast._tag) {
+      case 5 /* ASTTag.NeverKeyword */:
+        return tsplus_module_2.empty();
+      case 18 /* ASTTag.Union */:
+        return ast.types;
+      default:
+        return tsplus_module_2.vector(ast);
+    }
+  })(candidates);
+  if (tsplus_module_2.some(isStringKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !(isLiteral_1(m) && typeof m.literal === "string"))(out);
+  }
+  if (tsplus_module_2.some(isNumberKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !(isLiteral_1(m) && typeof m.literal === "number"))(out);
+  }
+  if (tsplus_module_2.some(isSymbolKeyword_1)(out)) {
+    out = tsplus_module_2.filter(m => !isUniqueSymbol_1(m))(out);
+  }
+  return out;
+}
+/**
+ * @tsplus pipeable fncts.schema.AST combineAnnotations
+ */
+export function combineAnnotations(annotations) {
+  return self => {
+    return self.clone({
+      annotations: self.annotations.combine(annotations)
+    });
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST setAnnotation
+ */
+export function setAnnotation(annotation, value) {
+  return self => {
+    return self.clone({
+      annotations: self.annotations.annotate(annotation, value)
+    });
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST appendRestElement
+ */
+export function appendRestElement(restElement) {
+  return self => {
+    if (tsplus_module_5.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)), self.isReadonly, self.annotations);
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST appendElement
+ */
+export function appendElement(element) {
+  return self => {
+    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(), 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)), self.isReadonly, self.annotations);
+    })(self.rest);
+  };
+}
+export function getParameter(x) {
+  return isRefinement(x) ? getParameter(x.from) : x;
+}
+/**
+ * @tsplus getter fncts.schema.AST getPropertySignatures
+ */
+function getPropertySignatures_1(self) {
+  void 0;
+  switch (self._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return getPropertySignatures_1(self.type);
+    case 16 /* ASTTag.Tuple */:
+      return tsplus_module_2.mapWithIndex((i, element) => createPropertySignature_1(i, element.type, element.isOptional, self.isReadonly))(self.elements);
+    case 18 /* ASTTag.Union */:
+      {
+        const propertySignatures = tsplus_module_2.map(getPropertySignatures_1)(self.types);
+        return tsplus_module_2.filterMap(({
+          name
+        }) => {
+          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)));
+          }
+          return tsplus_module_6.nothing();
+        })(tsplus_module_2.unsafeGet(0)(propertySignatures));
+      }
+    case 19 /* ASTTag.Lazy */:
+      return getPropertySignatures_1(self.getAST());
+    case 20 /* ASTTag.Refinement */:
+      return getPropertySignatures_1(self.from);
+    case 21 /* ASTTag.Transform */:
+      return getPropertySignatures_1(self.to);
+    default:
+      return tsplus_module_2.empty();
+  }
+}
+/**
+ * @tsplus getter fncts.schema.AST keysof
+ */
+function keysOf_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    case 0 /* ASTTag.Declaration */:
+      return keysOf_1(ast.type);
+    case 5 /* ASTTag.NeverKeyword */:
+    case 7 /* ASTTag.AnyKeyword */:
+      return tsplus_module_2.vector(stringKeyword_1, numberKeyword_1, symbolKeyword_1);
+    case 8 /* ASTTag.StringKeyword */:
+      return tsplus_module_2.vector(createLiteral_1("length"));
+    case 17 /* ASTTag.TypeLiteral */:
+      return tsplus_module_2.concat(tsplus_module_2.map(is => getParameter(is.parameter))(ast.indexSignatures))(tsplus_module_2.map(p => typeof p.name === "symbol" ? createUniqueSymbol_1(p.name) : createLiteral_1(p.name))(ast.propertySignatures));
+    case 18 /* ASTTag.Union */:
+      return tsplus_module_2.map(p => typeof p.name === "symbol" ? createUniqueSymbol_1(p.name) : createLiteral_1(p.name))(getPropertySignatures_1(ast));
+    case 19 /* ASTTag.Lazy */:
+      return keysOf_1(ast.getAST());
+    case 20 /* ASTTag.Refinement */:
+      return keysOf_1(ast.from);
+    case 21 /* ASTTag.Transform */:
+      return keysOf_1(ast.to);
+    default:
+      return tsplus_module_2.empty();
+  }
+}
+/**
+ * @tsplus getter fncts.schema.AST keyof
+ */
+export function keyof(self) {
+  return createUnion_1(keysOf_1(self));
+}
+/**
+ * @tsplus static fncts.schema.ASTOps createRecord
+ */
+export function createRecord(key, value, isReadonly) {
+  const propertySignatures = tsplus_module_2.emptyPushable();
+  const indexSignatures = tsplus_module_2.emptyPushable();
+  function go(key) {
+    void 0;
+    switch (key._tag) {
+      case 0 /* ASTTag.Declaration */:
+        go(key.type);
+        break;
+      case 5 /* ASTTag.NeverKeyword */:
+        break;
+      case 8 /* ASTTag.StringKeyword */:
+      case 12 /* ASTTag.SymbolKeyword */:
+      case 15 /* ASTTag.TemplateLiteral */:
+      case 20 /* ASTTag.Refinement */:
+        tsplus_module_8.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);
+        }
+        break;
+      case 2 /* ASTTag.UniqueSymbol */:
+        tsplus_module_8.push(createPropertySignature_1(key.symbol, value, false, isReadonly))(propertySignatures);
+        break;
+      case 18 /* ASTTag.Union */:
+        tsplus_module_2.forEach(go)(key.types);
+        break;
+      default:
+        throw new Error(`createRecord: Unsupported key\n${show(key)}`);
+    }
+  }
+  go(key);
+  return createTypeLiteral_1(propertySignatures, indexSignatures);
+}
+/**
+ * @tsplus pipeable fncts.schema.AST pick
+ */
+export function pick(keys) {
+  return self => {
+    return createTypeLiteral_1(tsplus_module_2.filter(ps => tsplus_module_2.includes(ps.name)(keys))(getPropertySignatures_1(self)), tsplus_module_2.empty());
+  };
+}
+/**
+ * @tsplus pipeable fncts.schema.AST omit
+ */
+export function omit(keys) {
+  return self => {
+    return createTypeLiteral_1(tsplus_module_2.filter(ps => !tsplus_module_2.includes(ps.name)(keys))(getPropertySignatures_1(self)), tsplus_module_2.empty());
+  };
+}
+/**
+ * @tsplus getter fncts.schema.AST partial
+ */
+function partial_1(self) {
+  void 0;
+  switch (self._tag) {
+    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);
+    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 */:
+      return createUnion_1(tsplus_module_2.map(partial_1)(self.types));
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => partial_1(self.getAST()));
+    case 20 /* ASTTag.Refinement */:
+      return partial_1(self.from);
+    case 21 /* ASTTag.Transform */:
+      return partial_1(self.to);
+    default:
+      return self;
+  }
+}
+/**
+ * @tsplus static fncts.schema.AST createKey
+ */
+export function createKey(key) {
+  return typeof key === "symbol" ? createUniqueSymbol_1(key) : createLiteral_1(key);
+}
+/**
+ * @tsplus getter fncts.schema.AST getFrom
+ */
+function getFrom_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    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);
+    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 */:
+      return createUnion_1(tsplus_module_2.map(getFrom_1)(ast.types), ast.annotations);
+    case 19 /* ASTTag.Lazy */:
+      return createLazy_1(() => getFrom_1(ast.getAST()), ast.annotations);
+    case 20 /* ASTTag.Refinement */:
+    case 21 /* ASTTag.Transform */:
+      return getFrom_1(ast.from);
+  }
+  return ast;
+}
+/**
+ * @tsplus getter fncts.schema.AST getTo
+ */
+function getTo_1(ast) {
+  void 0;
+  switch (ast._tag) {
+    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);
+    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 */:
+      return createUnion_1(tsplus_module_2.map(getTo_1)(ast.types), ast.annotations);
+    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);
+    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
+ */
+export function getCompiler(match) {
+  const compile = memoize(ast => {
+    void 0;
+    return match[ast._tag](ast, compile);
+  });
+  return compile;
+}
+//# sourceMappingURL=AST.mjs.map