@fncts/schema 0.0.24 → 0.0.25

package/_cjs/ParseError/ParseError.cjs

@@ -1,337 +1,336 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.UnionMemberError = exports.UnionError = exports.UnexpectedError = exports.TypeLiteralError = exports.TypeError = exports.TupleError = exports.TransformationError = exports.RefinementError = exports.MissingError = exports.KeyError = exports.IterableError = exports.IndexError = exports.DeclarationError = void 0;
-exports.declarationError = declarationError;
-exports.indexError = indexError;
-exports.iterableError = iterableError;
-exports.keyError = keyError;
-exports.missingError = void 0;
-exports.refinementError = refinementError;
-exports.transformationError = transformationError;
-exports.tupleError = tupleError;
-exports.typeError = typeError;
-exports.typeLiteralError = typeLiteralError;
-exports.unexpectedError = unexpectedError;
-exports.unionError = unionError;
-exports.unionMemberError = unionMemberError;
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard(/*#__PURE__*/require("@fncts/base/data/Equatable/definition"));
-function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_chunk = require("../chunk.cjs");
+let _fncts_base_data_Equatable_definition = require("@fncts/base/data/Equatable/definition");
+_fncts_base_data_Equatable_definition = require_chunk.__toESM(_fncts_base_data_Equatable_definition, 1);
+//#region build/esm/ParseError/ParseError.js
 function hasTag(u, tag) {
-  return typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
+	return typeof u === "object" && u !== null && "_tag" in u && u._tag === tag;
 }
 /**
- * @tsplus companion fncts.schema.ParseError.DeclarationError
- */
-class DeclarationError {
-  ast;
-  actual;
-  error;
-  _tag = 0 /* ParseErrorTag.Declaration */;
-  constructor(ast, actual, error) {
-    this.ast = ast;
-    this.actual = actual;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 0 /* ParseErrorTag.Declaration */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.DeclarationError
+*/
+var DeclarationError = class {
+	ast;
+	actual;
+	error;
+	_tag = 0;
+	constructor(ast, actual, error) {
+		this.ast = ast;
+		this.actual = actual;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 0) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.DeclarationError __call
- * @tsplus static fncts.schema.ParseErrorOps DeclarationError
- */
-exports.DeclarationError = DeclarationError;
+* @tsplus static fncts.schema.ParseError.DeclarationError __call
+* @tsplus static fncts.schema.ParseErrorOps DeclarationError
+*/
 function declarationError(ast, actual, error) {
-  return new DeclarationError(ast, actual, error);
+	return new DeclarationError(ast, actual, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.TypeError
- */
-class TypeError {
-  ast;
-  actual;
-  _tag = 1 /* ParseErrorTag.Type */;
-  constructor(ast, actual) {
-    this.ast = ast;
-    this.actual = actual;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 1 /* ParseErrorTag.Type */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.TypeError
+*/
+var TypeError = class {
+	ast;
+	actual;
+	_tag = 1;
+	constructor(ast, actual) {
+		this.ast = ast;
+		this.actual = actual;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 1) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.TypeError __call
- * @tsplus static fncts.schema.ParseErrorOps TypeError
- */
-exports.TypeError = TypeError;
+* @tsplus static fncts.schema.ParseError.TypeError __call
+* @tsplus static fncts.schema.ParseErrorOps TypeError
+*/
 function typeError(expected, actual) {
-  return new TypeError(expected, actual);
+	return new TypeError(expected, actual);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.TypeLiteralError
- */
-class TypeLiteralError {
-  ast;
-  actual;
-  errors;
-  output;
-  _tag = 9 /* ParseErrorTag.TypeLiteral */;
-  constructor(ast, actual, errors, output = {}) {
-    this.ast = ast;
-    this.actual = actual;
-    this.errors = errors;
-    this.output = output;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 9 /* ParseErrorTag.TypeLiteral */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors) && context.comparator(this.output, that.output);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.TypeLiteralError
+*/
+var TypeLiteralError = class {
+	ast;
+	actual;
+	errors;
+	output;
+	_tag = 9;
+	constructor(ast, actual, errors, output = {}) {
+		this.ast = ast;
+		this.actual = actual;
+		this.errors = errors;
+		this.output = output;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 9) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors) && context.comparator(this.output, that.output);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.TypeLiteralError __call
- * @tsplus static fncts.schema.ParseErrorOps TypeLiteralError
- */
-exports.TypeLiteralError = TypeLiteralError;
+* @tsplus static fncts.schema.ParseError.TypeLiteralError __call
+* @tsplus static fncts.schema.ParseErrorOps TypeLiteralError
+*/
 function typeLiteralError(ast, actual, errors, output = {}) {
-  return new TypeLiteralError(ast, actual, errors, output);
+	return new TypeLiteralError(ast, actual, errors, output);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.TupleError
- */
-class TupleError {
-  ast;
-  actual;
-  errors;
-  output;
-  _tag = 10 /* ParseErrorTag.Tuple */;
-  constructor(ast, actual, errors, output = []) {
-    this.ast = ast;
-    this.actual = actual;
-    this.errors = errors;
-    this.output = output;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 10 /* ParseErrorTag.Tuple */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors) && context.comparator(this.output, that.output);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.TupleError
+*/
+var TupleError = class {
+	ast;
+	actual;
+	errors;
+	output;
+	_tag = 10;
+	constructor(ast, actual, errors, output = []) {
+		this.ast = ast;
+		this.actual = actual;
+		this.errors = errors;
+		this.output = output;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 10) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors) && context.comparator(this.output, that.output);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.TupleError __call
- * @tsplus static fncts.schema.ParseErrorOps TupleError
- */
-exports.TupleError = TupleError;
+* @tsplus static fncts.schema.ParseError.TupleError __call
+* @tsplus static fncts.schema.ParseErrorOps TupleError
+*/
 function tupleError(ast, actual, errors, output = []) {
-  return new TupleError(ast, actual, errors, output);
+	return new TupleError(ast, actual, errors, output);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.IndexError
- */
-class IndexError {
-  index;
-  error;
-  _tag = 2 /* ParseErrorTag.Index */;
-  constructor(index, error) {
-    this.index = index;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 2 /* ParseErrorTag.Index */) && context.comparator(this.index, that.index) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.IndexError
+*/
+var IndexError = class {
+	index;
+	error;
+	_tag = 2;
+	constructor(index, error) {
+		this.index = index;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 2) && context.comparator(this.index, that.index) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.IndexError __call
- * @tsplus static fncts.schema.ParseErrorOps IndexError
- */
-exports.IndexError = IndexError;
+* @tsplus static fncts.schema.ParseError.IndexError __call
+* @tsplus static fncts.schema.ParseErrorOps IndexError
+*/
 function indexError(index, error) {
-  return new IndexError(index, error);
+	return new IndexError(index, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.KeyError
- */
-class KeyError {
-  keyAST;
-  key;
-  error;
-  _tag = 3 /* ParseErrorTag.Key */;
-  constructor(keyAST, key, error) {
-    this.keyAST = keyAST;
-    this.key = key;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 3 /* ParseErrorTag.Key */) && context.comparator(this.keyAST, that.keyAST) && context.comparator(this.key, that.key) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.KeyError
+*/
+var KeyError = class {
+	keyAST;
+	key;
+	error;
+	_tag = 3;
+	constructor(keyAST, key, error) {
+		this.keyAST = keyAST;
+		this.key = key;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 3) && context.comparator(this.keyAST, that.keyAST) && context.comparator(this.key, that.key) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.KeyError __call
- * @tsplus static fncts.schema.ParseErrorOps KeyError
- */
-exports.KeyError = KeyError;
+* @tsplus static fncts.schema.ParseError.KeyError __call
+* @tsplus static fncts.schema.ParseErrorOps KeyError
+*/
 function keyError(keyAST, key, error) {
-  return new KeyError(keyAST, key, error);
+	return new KeyError(keyAST, key, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.MissingError
- */
-class MissingError {
-  _tag = 4 /* ParseErrorTag.Missing */;
-  [tsplus_module_1.equalsSymbol](that) {
-    return hasTag(that, 4 /* ParseErrorTag.Missing */);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.MissingError
+*/
+var MissingError = class {
+	_tag = 4;
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that) {
+		return hasTag(that, 4);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseErrorOps MissingError
- */
-exports.MissingError = MissingError;
-const missingError = exports.missingError = /*#__PURE__*/new MissingError();
+* @tsplus static fncts.schema.ParseErrorOps MissingError
+*/
+const missingError = new MissingError();
 /**
- * @tsplus companion fncts.schema.ParseError.UnexpectedError
- */
-class UnexpectedError {
-  actual;
-  _tag = 5 /* ParseErrorTag.Unexpected */;
-  constructor(actual) {
-    this.actual = actual;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 5 /* ParseErrorTag.Unexpected */) && context.comparator(this.actual, that.actual);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.UnexpectedError
+*/
+var UnexpectedError = class {
+	actual;
+	_tag = 5;
+	constructor(actual) {
+		this.actual = actual;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 5) && context.comparator(this.actual, that.actual);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.UnexpectedError __call
- * @tsplus static fncts.schema.ParseErrorOps UnexpectedError
- */
-exports.UnexpectedError = UnexpectedError;
+* @tsplus static fncts.schema.ParseError.UnexpectedError __call
+* @tsplus static fncts.schema.ParseErrorOps UnexpectedError
+*/
 function unexpectedError(actual) {
-  return new UnexpectedError(actual);
+	return new UnexpectedError(actual);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.UnionError
- */
-class UnionError {
-  ast;
-  actual;
-  errors;
-  _tag = 11 /* ParseErrorTag.Union */;
-  constructor(ast, actual, errors) {
-    this.ast = ast;
-    this.actual = actual;
-    this.errors = errors;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 11 /* ParseErrorTag.Union */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.UnionError
+*/
+var UnionError = class {
+	ast;
+	actual;
+	errors;
+	_tag = 11;
+	constructor(ast, actual, errors) {
+		this.ast = ast;
+		this.actual = actual;
+		this.errors = errors;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 11) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.UnionError __call
- * @tsplus static fncts.schema.ParseErrorOps UnionError
- */
-exports.UnionError = UnionError;
+* @tsplus static fncts.schema.ParseError.UnionError __call
+* @tsplus static fncts.schema.ParseErrorOps UnionError
+*/
 function unionError(ast, actual, errors) {
-  return new UnionError(ast, actual, errors);
+	return new UnionError(ast, actual, errors);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.UnionMemberError
- */
-class UnionMemberError {
-  ast;
-  error;
-  _tag = 6 /* ParseErrorTag.UnionMember */;
-  constructor(ast, error) {
-    this.ast = ast;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 6 /* ParseErrorTag.UnionMember */) && context.comparator(this.ast, that.ast) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.UnionMemberError
+*/
+var UnionMemberError = class {
+	ast;
+	error;
+	_tag = 6;
+	constructor(ast, error) {
+		this.ast = ast;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 6) && context.comparator(this.ast, that.ast) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.UnionMemberError __call
- * @tsplus static fncts.schema.ParseErrorOps UnionMemberError
- */
-exports.UnionMemberError = UnionMemberError;
+* @tsplus static fncts.schema.ParseError.UnionMemberError __call
+* @tsplus static fncts.schema.ParseErrorOps UnionMemberError
+*/
 function unionMemberError(ast, error) {
-  return new UnionMemberError(ast, error);
+	return new UnionMemberError(ast, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.RefinementError
- */
-class RefinementError {
-  ast;
-  actual;
-  kind;
-  error;
-  _tag = 7 /* ParseErrorTag.Refinement */;
-  constructor(ast, actual, kind, error) {
-    this.ast = ast;
-    this.actual = actual;
-    this.kind = kind;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 7 /* ParseErrorTag.Refinement */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.kind, that.kind) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.RefinementError
+*/
+var RefinementError = class {
+	ast;
+	actual;
+	kind;
+	error;
+	_tag = 7;
+	constructor(ast, actual, kind, error) {
+		this.ast = ast;
+		this.actual = actual;
+		this.kind = kind;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 7) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.kind, that.kind) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.RefinementError __call
- * @tsplus static fncts.schema.ParseErrorOps RefinementError
- */
-exports.RefinementError = RefinementError;
+* @tsplus static fncts.schema.ParseError.RefinementError __call
+* @tsplus static fncts.schema.ParseErrorOps RefinementError
+*/
 function refinementError(ast, actual, kind, error) {
-  return new RefinementError(ast, actual, kind, error);
+	return new RefinementError(ast, actual, kind, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.TransformationError
- */
-class TransformationError {
-  ast;
-  actual;
-  kind;
-  error;
-  _tag = 8 /* ParseErrorTag.Transformation */;
-  constructor(ast, actual, kind, error) {
-    this.ast = ast;
-    this.actual = actual;
-    this.kind = kind;
-    this.error = error;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 8 /* ParseErrorTag.Transformation */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.kind, that.kind) && context.comparator(this.error, that.error);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.TransformationError
+*/
+var TransformationError = class {
+	ast;
+	actual;
+	kind;
+	error;
+	_tag = 8;
+	constructor(ast, actual, kind, error) {
+		this.ast = ast;
+		this.actual = actual;
+		this.kind = kind;
+		this.error = error;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 8) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.kind, that.kind) && context.comparator(this.error, that.error);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.TransformationError __call
- * @tsplus static fncts.schema.ParseErrorOps TransformationError
- */
-exports.TransformationError = TransformationError;
+* @tsplus static fncts.schema.ParseError.TransformationError __call
+* @tsplus static fncts.schema.ParseErrorOps TransformationError
+*/
 function transformationError(ast, actual, kind, error) {
-  return new TransformationError(ast, actual, kind, error);
+	return new TransformationError(ast, actual, kind, error);
 }
 /**
- * @tsplus companion fncts.schema.ParseError.IterableError
- */
-class IterableError {
-  ast;
-  actual;
-  errors;
-  _tag = 12 /* ParseErrorTag.Iterable */;
-  constructor(ast, actual, errors) {
-    this.ast = ast;
-    this.actual = actual;
-    this.errors = errors;
-  }
-  [tsplus_module_1.equalsSymbol](that, context) {
-    return hasTag(that, 12 /* ParseErrorTag.Iterable */) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors);
-  }
-}
+* @tsplus companion fncts.schema.ParseError.IterableError
+*/
+var IterableError = class {
+	ast;
+	actual;
+	errors;
+	_tag = 12;
+	constructor(ast, actual, errors) {
+		this.ast = ast;
+		this.actual = actual;
+		this.errors = errors;
+	}
+	[_fncts_base_data_Equatable_definition.equalsSymbol](that, context) {
+		return hasTag(that, 12) && context.comparator(this.ast, that.ast) && context.comparator(this.actual, that.actual) && context.comparator(this.errors, that.errors);
+	}
+};
 /**
- * @tsplus static fncts.schema.ParseError.IterableError __call
- * @tsplus static fncts.schema.ParseErrorOps IterableError
- */
-exports.IterableError = IterableError;
+* @tsplus static fncts.schema.ParseError.IterableError __call
+* @tsplus static fncts.schema.ParseErrorOps IterableError
+*/
 function iterableError(ast, actual, errors) {
-  return new IterableError(ast, actual, errors);
+	return new IterableError(ast, actual, errors);
 }
+//#endregion
+exports.DeclarationError = DeclarationError;
+exports.IndexError = IndexError;
+exports.IterableError = IterableError;
+exports.KeyError = KeyError;
+exports.MissingError = MissingError;
+exports.RefinementError = RefinementError;
+exports.TransformationError = TransformationError;
+exports.TupleError = TupleError;
+exports.TypeError = TypeError;
+exports.TypeLiteralError = TypeLiteralError;
+exports.UnexpectedError = UnexpectedError;
+exports.UnionError = UnionError;
+exports.UnionMemberError = UnionMemberError;
+exports.declarationError = declarationError;
+exports.indexError = indexError;
+exports.iterableError = iterableError;
+exports.keyError = keyError;
+exports.missingError = missingError;
+exports.refinementError = refinementError;
+exports.transformationError = transformationError;
+exports.tupleError = tupleError;
+exports.typeError = typeError;
+exports.typeLiteralError = typeLiteralError;
+exports.unexpectedError = unexpectedError;
+exports.unionError = unionError;
+exports.unionMemberError = unionMemberError;
+
 //# sourceMappingURL=ParseError.cjs.map