@fncts/schema 0.0.15 → 0.0.17

package/_src/Schema/api/maybe.ts

@@ -5,11 +5,9 @@ import type { Check } from "@fncts/typelevel";
  * @tsplus getter fncts.schema.Schema maybe
  */
 export function maybe<A>(value: Schema<A>): Schema<Maybe<A>> {
-  return Schema.declaration(
-    Vector(value),
-    maybeInline(value),
-    maybeParser,
-    ASTAnnotationMap.empty.annotate(ASTAnnotation.Identifier, "Maybe"),
+  return Schema.declaration(Vector(value), maybeParser(true), maybeParser(false)).annotate(
+    ASTAnnotation.Identifier,
+    `Maybe<${value.show()}>`,
   );
 }
 
@@ -36,33 +34,20 @@ export function deriveMaybe<A extends Maybe<any>>(
   return unsafeCoerce(maybeFromNullable(value));
 }
 
-function maybeParser<A>(value: Schema<A>): Parser<Maybe<A>> {
-  const schema = maybe(value);
-  return Parser.make((u, options) => {
-    if (!Maybe.isMaybe(u)) {
-      return ParseResult.fail(ParseError.TypeError(schema.ast, u));
-    }
-    Maybe.concrete(u);
-    if (u.isNothing()) {
-      return ParseResult.succeed(Nothing());
-    } else {
-      return value.decode(u.value, options).map((a) => Just(a));
-    }
-  });
-}
-
-function maybeInline<A>(value: Schema<A>): Schema<Maybe<A>> {
-  return Schema.union(
-    Schema.struct({
-      _tag: Schema.literal("Nothing"),
-      [Symbol.equals]: Schema.any,
-      [Symbol.hash]: Schema.any,
-    }),
-    Schema.struct({
-      _tag: Schema.literal("Just"),
-      value,
-      [Symbol.equals]: Schema.any,
-      [Symbol.hash]: Schema.any,
-    }),
-  ) as unknown as Schema<Maybe<A>>;
+function maybeParser(isDecoding: boolean) {
+  return <A>(value: Schema<A>): Parser<Maybe<unknown>> => {
+    const schema     = maybe(value);
+    const parseValue = isDecoding ? value.decode : value.encode;
+    return Parser.make((u, options) => {
+      if (!Maybe.isMaybe(u)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+      }
+      Maybe.concrete(u);
+      if (u.isNothing()) {
+        return ParseResult.succeed(Nothing());
+      } else {
+        return parseValue(u.value, options).map((a) => Just(a));
+      }
+    });
+  };
 }

package/_src/Schema/api/set.ts

@@ -0,0 +1,74 @@
+import type { KeyError } from "@fncts/schema/ParseError";
+import type { Sized } from "@fncts/test/control/Sized";
+
+/**
+ * @tsplus static fncts.schema.SchemaOps map
+ */
+export function set<V>(value: Schema<V>): Schema<Set<V>> {
+  return Schema.declaration(Vector(value), setParser(true), setParser(false))
+    .annotate(ASTAnnotation.Identifier, `Set<${value.show()}>`)
+    .annotate(ASTAnnotation.GenHook, gen);
+}
+
+/**
+ * @tsplus static fncts.schema.SchemaOps mapFromRecord
+ */
+export function setFromArray<V>(value: Schema<V>): Schema<Set<V>> {
+  return Schema.array(value).transform(
+    set(value),
+    (input) => {
+      return new Set(input);
+    },
+    (input) => {
+      return Array.from(input);
+    },
+  );
+}
+
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Set]<_> 10
+ */
+export function deriveSet<A extends Set<any>>(
+  ...[value]: [A] extends [Set<infer V>]
+    ? Check<Check.IsEqual<A, Set<V>>> extends Check.True
+      ? [value: Schema<V>]
+      : never
+    : never
+): Schema<A> {
+  return unsafeCoerce(setFromArray(value));
+}
+
+function setParser(isDecoding: boolean) {
+  return <A>(value: Schema<A>): Parser<Set<unknown>> => {
+    const schema     = set(value);
+    const parseValue = isDecoding ? value.decode : value.encode;
+    return Parser.make((u, options) => {
+      if (!(u instanceof Set)) {
+        return ParseResult.fail(ParseError.TypeError(schema.ast, u));
+      }
+
+      const allErrors = options?.allErrors;
+      const errors    = Vector.emptyPushable<KeyError>();
+      const out       = new Set();
+      for (const v of u) {
+        const tv = parseValue(v, options);
+        Either.concrete(tv);
+        if (tv.isLeft()) {
+          errors.push(ParseError.KeyError(value.ast, value, tv.left));
+          if (!allErrors) {
+            return ParseResult.fail(ParseError.IterableError(schema.ast, u, errors));
+          }
+          continue;
+        }
+        out.add(tv.right);
+      }
+      return errors.isNonEmpty()
+        ? ParseResult.fail(ParseError.IterableError(schema.ast, u, errors))
+        : ParseResult.succeed(out);
+    });
+  };
+}
+
+function gen<V>(value: Gen<Sized, V>): Gen<Sized, Set<V>> {
+  return Gen.array(value).map((values) => new Set(values));
+}

package/_src/Schema/api.ts

@@ -28,15 +28,15 @@ export function annotate<V>(annotation: ASTAnnotation<V>, value: V) {
  */
 export function declaration(
   typeParameters: Vector<Schema<any>>,
-  type: Schema<any>,
   decode: (...typeParameters: ReadonlyArray<Schema<any>>) => Parser<any>,
+  encode: (...typeParameters: ReadonlyArray<Schema<any>>) => Parser<any>,
   annotations?: ASTAnnotationMap,
 ): Schema<any> {
   return Schema.fromAST(
     AST.createDeclaration(
       typeParameters.map((tp) => tp.ast),
-      type.ast,
       (...typeParameters) => decode(...typeParameters.map(Schema.fromAST)),
+      (...typeParameters) => encode(...typeParameters.map(Schema.fromAST)),
       annotations,
     ),
   );
@@ -177,8 +177,8 @@ export const implicitDate: Schema<Date> = Schema.unknown.transformOrFail(
 );
 
 /**
- * @tsplus static fncts.schema.SchemaOps union
  * @tsplus derive fncts.schema.Schema<|> 30
+ * @tsplus static fncts.schema.SchemaOps union
  */
 export function union<A extends ReadonlyArray<unknown>>(
   ...members: {
@@ -541,3 +541,21 @@ export function transform<A, B>(
     );
   };
 }
+
+/**
+ * @tsplus pipeable fncts.schema.Schema pick
+ */
+export function pick<A, Keys extends ReadonlyArray<keyof A>>(...keys: Keys) {
+  return (self: Schema<A>): Schema<Pick<A, Keys[number]>> => {
+    return Schema.fromAST(self.ast.pick(Vector.from(keys)));
+  };
+}
+
+/**
+ * @tsplus pipeable fncts.schema.Schema omit
+ */
+export function omit<A, Keys extends ReadonlyArray<keyof A>>(...keys: Keys) {
+  return (self: Schema<A>): Schema<Omit<A, Keys[number]>> => {
+    return Schema.fromAST(self.ast.omit(Vector.from(keys)));
+  };
+}

package/_src/Schema/derivations.ts

@@ -51,7 +51,7 @@ export function deriveStruct<A extends Record<string, any>>(
           ? [optionalFields: {}]
           : [
               optionalFields: {
-                [k in OptionalKeys<A>]: Schema<NonNullable<A[k]>>;
+                [k in OptionalKeys<A>]: Schema<A[k]>;
               },
             ]),
         ...([MaybeKeys<A>] extends [never]

package/_src/Schema.ts

@@ -7,7 +7,9 @@ export * from "./Schema/api.js";
 
 /* eslint-disable simple-import-sort/exports */
 // codegen:start { preset: barrel, include: ./Schema/api/*.ts }
+export * from "./Schema/api/set.js";
 export * from "./Schema/api/maybe.js";
+export * from "./Schema/api/map.js";
 export * from "./Schema/api/list.js";
 export * from "./Schema/api/immutableArray.js";
 export * from "./Schema/api/hashSet.js";

package/_src/Show.ts

@@ -1,169 +1,117 @@
-import type { TemplateLiteral, TemplateLiteralSpan } from "@fncts/schema/AST";
+import type {
+  Element,
+  Refinement,
+  StringKeyword,
+  SymbolKeyword,
+  TemplateLiteral,
+  TemplateLiteralSpan,
+  Tuple,
+  TypeLiteral,
+} from "@fncts/schema/AST";
 
 import { globalValue } from "@fncts/base/data/Global";
 import { ASTTag } from "@fncts/schema/AST";
-import { ASTAnnotation } from "@fncts/schema/ASTAnnotation";
-import { memoize } from "@fncts/schema/utils";
+import { formatUnknown } from "@fncts/schema/utils";
 
-const showMemoMap = globalValue(Symbol.for("fncts.schema.Guard.showMemoMap"), () => new WeakMap<AST, Eval<string>>());
+const showMemoMap = globalValue(Symbol.for("fncts.schema.Guard.showMemoMap"), () => new WeakMap<AST, string>());
+const showMemoMapVerbose = globalValue(
+  Symbol.for("fncts.schema.Guard.showMemoMapVerbose"),
+  () => new WeakMap<AST, string>(),
+);
 
-function goMemo(ast: AST): Eval<string> {
-  const memo = showMemoMap.get(ast);
+function goMemo(ast: AST, verbose: boolean): string {
+  const memoMap = verbose ? showMemoMapVerbose : showMemoMap;
+  const memo = memoMap.get(ast);
   if (memo) {
     return memo;
   }
-  const s = go(ast);
-  showMemoMap.set(ast, s);
+  const s = go(ast, verbose);
+  memoMap.set(ast, s);
   return s;
 }
 
 /**
- * @tsplus getter fncts.schema.Schema show
+ * @tsplus pipeable fncts.schema.Schema show
  */
-export function show<A>(self: Schema<A>): string {
-  const ev = goMemo(self.ast);
-  return ev.run;
+export function show(verbose: boolean = false) {
+  return <A>(self: Schema<A>): string => goMemo(self.ast, verbose);
 }
 
-function go(ast: AST): Eval<string> {
+/**
+ * @tsplus pipeable fncts.schema.AST show
+ */
+export function showAST(verbose: boolean = false) {
+  return (self: AST): string => goMemo(self, verbose);
+}
+
+function go(ast: AST, verbose: boolean): string {
   AST.concrete(ast);
   switch (ast._tag) {
     case ASTTag.Declaration: {
-      return ast.annotations.get(ASTAnnotation.Identifier).match(
-        () => Eval.now("Unknown Type"),
-        (id) => {
-          return ast.typeParameters
-            .traverse(Eval.Applicative)(goMemo)
-            .map((ts) => {
-              if (ts.length <= 0) {
-                return id;
-              } else {
-                return `${id}<${ts.join(", ")}>`;
-              }
-            });
-        },
-      );
-    }
-    case ASTTag.Literal: {
-      if (ast.literal === null) {
-        return Eval.now("null");
-      } else {
-        return Eval.now(ast.literal.toString());
-      }
+      return ast.getFormattedExpected(verbose).getOrElse("<declaration schema>");
     }
+    case ASTTag.Literal:
+      return ast.getFormattedExpected(verbose).getOrElse(formatUnknown(ast.literal));
     case ASTTag.UniqueSymbol:
-      return Eval.now(ast.symbol.toString());
+      return ast.getFormattedExpected(verbose).getOrElse(formatUnknown(ast.symbol));
     case ASTTag.UndefinedKeyword:
-      return Eval.now("undefined");
+      return ast.getFormattedExpected(verbose).getOrElse("undefined");
     case ASTTag.VoidKeyword:
-      return Eval.now("void");
+      return ast.getFormattedExpected(verbose).getOrElse("void");
     case ASTTag.NeverKeyword:
-      return Eval.now("never");
+      return ast.getFormattedExpected(verbose).getOrElse("never");
     case ASTTag.UnknownKeyword:
-      return Eval.now("unknown");
+      return ast.getFormattedExpected(verbose).getOrElse("unknown");
     case ASTTag.AnyKeyword:
-      return Eval.now("any");
+      return ast.getFormattedExpected(verbose).getOrElse("any");
     case ASTTag.StringKeyword:
-      return Eval.now("string");
+      return ast.getFormattedExpected(verbose).getOrElse("string");
     case ASTTag.NumberKeyword:
-      return Eval.now("number");
+      return ast.getFormattedExpected(verbose).getOrElse("number");
     case ASTTag.BooleanKeyword:
-      return Eval.now("boolean");
+      return ast.getFormattedExpected(verbose).getOrElse("boolean");
     case ASTTag.BigIntKeyword:
-      return Eval.now("bigint");
+      return ast.getFormattedExpected(verbose).getOrElse("bigint");
     case ASTTag.SymbolKeyword:
-      return Eval.now("symbol");
+      return ast.getFormattedExpected(verbose).getOrElse("symbol");
     case ASTTag.ObjectKeyword:
-      return Eval.now("object");
+      return ast.getFormattedExpected(verbose).getOrElse("object");
     case ASTTag.TemplateLiteral:
-      return Eval.now("`" + formatTemplateLiteral(ast) + "`");
-    case ASTTag.Tuple:
-      return Do((Δ) => {
-        const elements     = Δ(ast.elements.traverse(Eval.Applicative)((element) => goMemo(element.type)));
-        const restElements = Δ(
-          ast.rest.match(
-            () => Eval.now(Vector.empty<string>()),
-            (rest) => rest.traverse(Eval.Applicative)(goMemo),
-          ),
-        );
-
-        return Δ(
-          Eval(() => {
-            if (elements.length === 0 && restElements.length === 1) {
-              if (ast.isReadonly) {
-                return `ReadonlyArray<${restElements[0]}>`;
-              } else {
-                return `Array<${restElements[0]}>`;
-              }
-            }
-
-            const prefix = (ast.isReadonly ? "readonly " : "") + "[" + elements.join(", ");
-            const middle = restElements.length > 0 ? ", " : "";
-            const suffix = restElements.map((s) => `...${s}`).join(", ") + "]";
-            return prefix + middle + suffix;
-          }),
-        );
-      });
-    case ASTTag.TypeLiteral:
-      return Do((Δ) => {
-        const propertySignatures = Δ(ast.propertySignatures.traverse(Eval.Applicative)((ps) => goMemo(ps.type)));
-        const indexSignatures    = Δ(
-          ast.indexSignatures.traverse(Eval.Applicative)((is) => goMemo(is.parameter).zip(goMemo(is.type))),
-        );
-
-        const required: Array<[PropertyKey, string]> = [];
-        const optional: Array<[PropertyKey, string]> = [];
-
-        ast.propertySignatures.forEachWithIndex((i, ps) => {
-          const name = ps.name;
-          if (!ps.isOptional) {
-            required.push([name, propertySignatures[i]!]);
-          } else {
-            optional.push([name, propertySignatures[i]!]);
-          }
-        });
-
-        const prefix     = "{";
-        const properties = required
-          .concat(optional)
-          .sort(([k1], [k2]) => k1.toLocaleString().localeCompare(k2.toLocaleString()))
-          .map(([propertyKey, type]) => `${String(propertyKey)}: ${type}`)
-          .join(", ");
-        const index  = indexSignatures.map(([param, type]) => `[x: ${param}]: ${type}`).join(", ");
-        const suffix = "}";
-
-        return prefix + " " + properties + (index.length === 0 ? "" : ", ") + index + " " + suffix;
-      });
-    case ASTTag.Union:
-      return ast.types
-        .traverse(Eval.Applicative)(goMemo)
-        .map((ts) => ts.join(" | "));
+      return ast.getFormattedExpected(verbose).getOrElse(formatTemplateLiteral(ast));
+    case ASTTag.Tuple: {
+      return ast.getFormattedExpected(verbose).getOrElse(formatTuple(ast, verbose));
+    }
+    case ASTTag.TypeLiteral: {
+      return ast.getFormattedExpected(verbose).getOrElse(formatTypeLiteral(ast, verbose));
+    }
+    case ASTTag.Union: {
+      return ast.getFormattedExpected(verbose).getOrElse(ast.types.map((ast) => goMemo(ast, verbose)).join(" | "));
+    }
     case ASTTag.Lazy: {
-      const f   = () => goMemo(ast.getAST());
-      const get = memoize<void, Eval<string>>(f);
-      return Eval.defer(() => get());
+      return ast
+        .getFormattedExpected(verbose)
+        .orElse(Maybe.tryCatch(ast.getAST).flatMap((ast) => ast.getFormattedExpected(verbose)))
+        .getOrElse("<lazy schema>");
     }
     case ASTTag.Enum: {
-      return Eval.now(ast.enums.map(([name]) => name).join(" | "));
+      return ast
+        .getFormattedExpected(verbose)
+        .getOrElse(
+          `<enum ${ast.enums.length} values(s): ${ast.enums.map(([_, value]) => JSON.stringify(value)).join(" | ")}`,
+        );
     }
     case ASTTag.Refinement: {
-      return ast.annotations.get(ASTAnnotation.Identifier).match(
-        () => goMemo(ast.from).map((from) => `Refined<${from}>`),
-        (id) => Eval.now(id),
-      );
+      return ast.getFormattedExpected(verbose).getOrElse(`{ ${goMemo(ast.from, verbose)} | filter }`);
+    }
+    case ASTTag.Transform: {
+      return ast
+        .getFormattedExpected(verbose)
+        .getOrElse(`(${goMemo(ast.from, verbose)} <-> ${goMemo(ast.to, verbose)})`);
     }
-    case ASTTag.Transform:
-      return goMemo(ast.to);
     case ASTTag.Validation: {
-      return goMemo(ast.from).map((from) => {
-        const validationNames = ast.validation.map((v) => v.name).join(" & ");
-
-        if (validationNames.length <= 0) {
-          return from;
-        }
-
-        return `${from} & ${validationNames}`;
-      });
+      return ast
+        .getFormattedExpected(verbose)
+        .getOrElse(`${goMemo(ast.from, verbose)} (${ast.validation.map((v) => v.name).join(" & ")})`);
     }
   }
 }
@@ -178,5 +126,85 @@ function formatTemplateLiteralSpan(span: TemplateLiteralSpan): string {
 }
 
 function formatTemplateLiteral(ast: TemplateLiteral): string {
-  return ast.head + ast.spans.map((span) => formatTemplateLiteralSpan(span) + span.literal).join("");
+  return "`" + ast.head + ast.spans.map((span) => formatTemplateLiteralSpan(span) + span.literal).join("") + "`";
+}
+
+function formatElement(ast: Element, verbose: boolean): string {
+  return goMemo(ast.type, verbose) + (ast.isOptional ? "?" : "");
+}
+
+function getParameterBase(
+  self: StringKeyword | SymbolKeyword | TemplateLiteral | Refinement,
+): StringKeyword | SymbolKeyword | TemplateLiteral {
+  switch (self._tag) {
+    case ASTTag.StringKeyword:
+    case ASTTag.SymbolKeyword:
+    case ASTTag.TemplateLiteral:
+      return self;
+    case ASTTag.Refinement:
+      return getParameterBase(self);
+  }
+}
+
+function formatTuple(ast: Tuple, verbose: boolean): string {
+  const formattedElements = ast.elements.map((element) => formatElement(element, verbose)).join(", ");
+  return ast.rest
+    .filter((rest) => rest.isNonEmpty())
+    .match(
+      () => `${ast.isReadonly ? "readonly " : ""}[${formattedElements}]`,
+      (rest) => {
+        const head = rest.unsafeHead!;
+        const tail = rest.tail;
+        const formattedHead = goMemo(head, verbose);
+        const wrappedHead = formattedHead.includes(" | ") ? `(${formattedHead})` : formattedHead;
+
+        if (tail.length > 0) {
+          const formattedTail = tail.map((ast) => goMemo(ast, verbose)).join(", ");
+          if (ast.elements.length > 0) {
+            return `${ast.isReadonly ? "readonly " : " "}[${formattedElements}, ...${wrappedHead}[], ${formattedTail}]`;
+          } else {
+            return `${ast.isReadonly ? "readonly " : " "}[...${wrappedHead}[], ${formattedTail}]`;
+          }
+        } else {
+          if (ast.elements.length > 0) {
+            return `${ast.isReadonly ? "readonly " : " "}[${formattedElements}, ...${wrappedHead}[]]`;
+          } else {
+            return `${ast.isReadonly ? "Readonly" : ""}Array<${formattedHead}>`;
+          }
+        }
+      },
+    );
+}
+
+function formatTypeLiteral(ast: TypeLiteral, verbose: boolean): string {
+  const formattedPropertySignatures = ast.propertySignatures
+    .map(
+      (ps) =>
+        (ps.isReadonly ? "readonly " : "") +
+        String(ps.name) +
+        (ps.isOptional ? "?" : "") +
+        ": " +
+        goMemo(ps.type, verbose),
+    )
+    .join("; ");
+  if (ast.indexSignatures.length > 0) {
+    const formattedIndexSignatures = ast.indexSignatures
+      .map(
+        (is) =>
+          (is.isReadonly ? "readonly " : "") +
+          `[x: ${goMemo(getParameterBase(is.parameter), verbose)}]: ${goMemo(is.type, verbose)}`,
+      )
+      .join("; ");
+    if (ast.propertySignatures.length > 0) {
+      return `{ ${formattedPropertySignatures}; ${formattedIndexSignatures} }`;
+    } else {
+      return `{ ${formattedIndexSignatures} }`;
+    }
+  } else {
+    if (ast.propertySignatures.length > 0) {
+      return `{ ${formattedPropertySignatures} }`;
+    } else {
+      return "{}";
+    }
+  }
 }

package/_src/global.ts

@@ -39,10 +39,6 @@ import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
  * @tsplus global
  */
 import { ParseError } from "@fncts/schema/ParseError";
-/**
- * @tsplus global
- */
-import { ParseFailure } from "@fncts/schema/ParseFailure";
 /**
  * @tsplus global
  */

package/_src/utils.ts

@@ -1,6 +1,7 @@
 import type { IndexSignature, TemplateLiteral } from "./AST";
 
 import { ASTTag } from "./AST.js";
+import { showWithOptions } from "@fncts/base/data/Showable";
 
 export function memoize<A, B>(f: (a: A) => B): (a: A) => B {
   const cache = new Map();
@@ -46,3 +47,7 @@ export function getKeysForIndexSignature(
       return getKeysForIndexSignature(input, parameter.from as any);
   }
 }
+
+export function formatUnknown(u: unknown): string {
+  return showWithOptions(u, {});
+}

package/global.d.ts

@@ -38,10 +38,6 @@ import { ASTAnnotationMap } from "@fncts/schema/ASTAnnotationMap";
  * @tsplus global
  */
 import { ParseError } from "@fncts/schema/ParseError";
-/**
- * @tsplus global
- */
-import { ParseFailure } from "@fncts/schema/ParseFailure";
 /**
  * @tsplus global
  */

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@fncts/schema",
-  "version": "0.0.15",
+  "version": "0.0.17",
   "dependencies": {
-    "@fncts/base": "0.0.35",
+    "@fncts/base": "0.0.36",
     "@fncts/typelevel": "0.0.18"
   },
   "exports": {

package/utils.d.ts

@@ -6,3 +6,4 @@ export declare function getTemplateLiteralRegex(ast: TemplateLiteral): RegExp;
 export declare function getKeysForIndexSignature(input: {
     readonly [x: PropertyKey]: unknown;
 }, parameter: IndexSignature["parameter"]): Vector<string> | Vector<symbol>;
+export declare function formatUnknown(u: unknown): string;

package/ParseFailure.d.ts

@@ -1,18 +0,0 @@
-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/_cjs/ParseFailure.cjs

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.ParseFailureTypeId = exports.ParseFailure = void 0;
-exports.make = make;
-var _a;
-const ParseFailureTypeId = exports.ParseFailureTypeId = /*#__PURE__*/Symbol.for("fncts.schema.ParseFailure");
-/**
- * @tsplus type fncts.schema.ParseFailure
- * @tsplus companion fncts.schema.ParseFailureOps
- */
-class ParseFailure {
-  constructor(errors) {
-    this.errors = errors;
-    this[_a] = ParseFailureTypeId;
-  }
-}
-exports.ParseFailure = ParseFailure;
-_a = ParseFailureTypeId;
-/**
- * @tsplus static fncts.schema.ParseFailureOps __call
- */
-function make(errors) {
-  return new ParseFailure(errors);
-}
-//# sourceMappingURL=ParseFailure.cjs.map

package/_cjs/ParseFailure.cjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ParseFailure.cjs","names":["ParseFailureTypeId","exports","Symbol","for","ParseFailure","constructor","errors","_a","make"],"sources":["../_src/ParseFailure.ts"],"sourcesContent":[null],"mappings":";;;;;;;;AAAO,MAAMA,kBAAkB,GAAAC,OAAA,CAAAD,kBAAA,gBAAGE,MAAM,CAACC,GAAG,CAAC,2BAA2B,CAAC;AAGzE;;;;AAIM,MAAOC,YAAY;EAEvBC,YAAqBC,MAA0B;IAA1B,KAAAA,MAAM,GAANA,MAAM;IADlB,KAAAC,EAAA,CAAoB,GAAuBP,kBAAkB;EACpB;;AACnDC,OAAA,CAAAG,YAAA,GAAAA,YAAA;KAFWJ,kBAAkB;AAI9B;;;AAGM,SAAUQ,IAAIA,CAACF,MAA0B;EAC7C,OAAO,IAAIF,YAAY,CAACE,MAAM,CAAC;AACjC"}

package/_mjs/ParseFailure.mjs

@@ -1,20 +0,0 @@
-var _a;
-export const ParseFailureTypeId = /*#__PURE__*/Symbol.for("fncts.schema.ParseFailure");
-/**
- * @tsplus type fncts.schema.ParseFailure
- * @tsplus companion fncts.schema.ParseFailureOps
- */
-export class ParseFailure {
-  constructor(errors) {
-    this.errors = errors;
-    this[_a] = ParseFailureTypeId;
-  }
-}
-_a = ParseFailureTypeId;
-/**
- * @tsplus static fncts.schema.ParseFailureOps __call
- */
-export function make(errors) {
-  return new ParseFailure(errors);
-}
-//# sourceMappingURL=ParseFailure.mjs.map