@pedrohb/errors 0.0.0-stage → 1.0.0

package/dist/index.cjs

@@ -0,0 +1,637 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_invalid_param_delimiters_error = require("./invalid-param-delimiters-error-C6UxV7cK.cjs");
+const require_errors = require("./errors-TgPe2YUV.cjs");
+const require_functions_index = require("./functions/index.cjs");
+require("./types/index.cjs");
+//#region src/interpolate-error-message.ts
+/**
+* Interpola os parâmetros informados na mensagem de um descritor de erro
+* substituindo cada placeholder pelo valor correspondente.
+*
+* Os placeholders são localizados com {@link createParamPlaceholder} a partir
+* dos delimitadores informados. O nome de cada placeholder é aparado
+* (`{ id }` equivale a `{id}`) e o valor é convertido para texto com `String`.
+*
+* O placeholder é mantido exatamente como está na mensagem (sem substituição)
+* quando:
+* - o nome é vazio (ex.: `{}` ou `{   }`);
+* - o nome não existe como propriedade própria de `params`.
+*
+* O objeto de parâmetros é exigido ou omitido conforme a mensagem via
+* {@link ErrorMessageArgs}: mensagens sem placeholders não aceitam `params` e
+* mensagens com placeholders exigem todos eles.
+*
+* @template Descriptor - Tipo do descritor de erro cuja `message` define os
+* parâmetros exigidos.
+* @template Delimiters - Tipo dos delimitadores dos placeholders. Por padrão,
+* {@link DefaultParamDelimiters}.
+* @param descriptor - Descritor de erro cuja mensagem será interpolada.
+* @param delimiters - Delimitadores `open` e `close` dos placeholders.
+* @param args - Objeto `params` com os valores dos placeholders exigido
+* apenas se a mensagem tiver placeholders.
+* @returns A mensagem com os placeholders substituídos.
+* @throws {InvalidParamDelimitersError} Se `open` ou `close` for uma string
+* vazia (lançado por {@link createParamPlaceholder}).
+*
+* @example
+* ```ts
+* const keys = { open: "{", close: "}" } as const;
+*
+* const USER_NOT_FOUND = {
+*   code: "USER_NOT_FOUND",
+*   message: "Usuário {id} não encontrado em {table}",
+* } as const satisfies ErrorDescriptor;
+*
+* interpolateErrorMessage(USER_NOT_FOUND, keys, {
+*   id: 42,
+*   table: "users",
+* });
+* // "Usuário 42 não encontrado em users"
+*
+* const INVALID_TOKEN = {
+*   code: "INVALID_TOKEN",
+*   message: "Token inválido",
+* } as const satisfies ErrorDescriptor;
+*
+* interpolateErrorMessage(INVALID_TOKEN, keys);
+* // "Token inválido" (sem params)
+*
+* // Delimitadores personalizados
+* const ROUTE_NOT_FOUND = {
+*   code: "ROUTE_NOT_FOUND",
+*   message: "Rota [route] não encontrada",
+* } as const satisfies ErrorDescriptor;
+*
+* interpolateErrorMessage(
+*   ROUTE_NOT_FOUND,
+*   { open: "[", close: "]" } as const,
+*   { route: "/home" },
+* );
+* // "Rota /home não encontrada"
+* ```
+*/
+function interpolateErrorMessage(descriptor, delimiters, ...args) {
+	const params = args[0] ?? {};
+	const placeholder = require_functions_index.createParamPlaceholder(delimiters);
+	return descriptor.message.replace(placeholder, (match, rawKey) => {
+		const key = rawKey.trim();
+		if (key === "" || !Object.hasOwn(params, key)) return match;
+		return String(params[key]);
+	});
+}
+//#endregion
+//#region src/base-error.ts
+/**
+* Classe base abstrata para erros tipados a partir de um catálogo de erros.
+*
+* Cada erro é criado a partir de um descritor do catálogo (código e mensagem).
+* A mensagem é interpolada com os `params` informados e o tipo dos `params` é
+* derivado dos placeholders da mensagem, de modo que o compilador exige
+* exatamente os parâmetros necessários.
+*
+* O construtor é `protected`: a classe não pode ser instanciada diretamente e
+* deve ser estendida por classes que escolhem o descritor e repassam as
+* opções.
+*
+* Além de `message`, `cause`, `stack` e `name` herdados de `Error`, a
+* instância expõe:
+* - `code`: o código do erro, com tipo literal;
+* - `params`: os parâmetros usados na interpolação (ou `undefined`);
+* - {@link BaseError.serialize} e {@link BaseError.toJSON} para serialização;
+* - uma marca interna ({@link BASE_ERROR_BRAND}) que permite reconhecer o
+*   erro com {@link isBaseError} mesmo com múltiplas cópias do pacote.
+*
+* O `name` do erro é o nome da classe concreta (`new.target.name`) e o
+* protótipo é ajustado explicitamente para que `instanceof` funcione em
+* subclasses mesmo em alvos de compilação antigos.
+*
+* @template Catalog - Catálogo de erros ao qual o código pertence. Por padrão,
+* `ErrorCatalog`.
+* @template Code - Código do erro dentro do catálogo. Por padrão, todos os
+* códigos do catálogo.
+* @template Delimiters - Tipo dos delimitadores dos placeholders. Por padrão,
+* {@link DefaultParamDelimiters}.
+*
+* @example
+* ```ts
+* const TEST_ERROR_CODES = defineErrorCatalog({
+*   USER_NOT_FOUND: "Usuário {id} não encontrado",
+*   INVALID_TOKEN: "Token inválido",
+* });
+*
+* type TestErrorCodes = typeof TEST_ERROR_CODES;
+*
+* class UserNotFoundError extends BaseError<TestErrorCodes, "USER_NOT_FOUND"> {
+*   public constructor(id: number, options?: ErrorOptions) {
+*     super(TEST_ERROR_CODES.USER_NOT_FOUND, { params: { id }, ...options });
+*   }
+* }
+*
+* class InvalidTokenError extends BaseError<TestErrorCodes, "INVALID_TOKEN"> {
+*   public constructor(options?: ErrorOptions) {
+*     super(TEST_ERROR_CODES.INVALID_TOKEN, options);
+*   }
+* }
+*
+* const erro = new UserNotFoundError(42);
+* erro.message; // "Usuário 42 não encontrado"
+* erro.code;    // "USER_NOT_FOUND"
+* erro.params;  // { id: 42 }
+* erro.name;    // "UserNotFoundError"
+*
+* BaseError.is(erro);                // true
+* JSON.stringify(erro);              // usa toJSON(), sem stack trace
+* erro.serialize(true);              // inclui o stack trace
+* ```
+*/
+var BaseError = class extends Error {
+	/** Código do erro conforme o catálogo (ex.: `"USER_NOT_FOUND"`). */
+	code;
+	/**
+	* Parâmetros usados para interpolar a mensagem. É `undefined` quando a
+	* mensagem não possui placeholders (ou quando nenhum `params` foi informado).
+	*/
+	params;
+	/**
+	* Cria um erro a partir de um descritor do catálogo.
+	*
+	* A mensagem do descritor é interpolada com `options.params` usando os
+	* delimitadores de `options.delimiters` (por padrão,
+	* {@link DEFAULT_PARAM_DELIMITERS}). Os delimitadores são usados apenas na
+	* interpolação e não são armazenados na instância. O objeto `options`
+	* também é repassado ao construtor de `Error`, que utiliza `cause`.
+	*
+	* É `protected` então só pode ser chamado por subclasses.
+	*
+	* @param descriptor - Descritor do erro no catálogo com `code` e `message`.
+	* @param args - Opções do erro ({@link BaseErrorOptions}). São obrigatórias
+	* se a mensagem tiver placeholders (por conter `params`) e opcionais caso
+	* contrário.
+	* @throws {InvalidParamDelimitersError} Se algum dos delimitadores for uma
+	* string vazia (lançado durante a interpolação).
+	*/
+	constructor(descriptor, ...args) {
+		const options = args[0];
+		const delimiters = options?.delimiters ?? require_functions_index.DEFAULT_PARAM_DELIMITERS;
+		const params = options && "params" in options ? options.params : void 0;
+		super(interpolateErrorMessage(descriptor, delimiters, ...params === void 0 ? [] : [params]), options);
+		this.name = new.target.name;
+		this.code = descriptor.code;
+		this.params = params;
+		Object.setPrototypeOf(this, new.target.prototype);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, new.target);
+	}
+	/**
+	* Marca interna que identifica a instância como um `BaseError`.
+	*
+	* Sempre retorna `true` e é lida por {@link isBaseError}. Por ser um
+	* getter definido no protótipo, não é uma propriedade própria da instância
+	* e portanto, não aparece em serializações nem em `Object.keys`.
+	*/
+	get [require_functions_index.BASE_ERROR_BRAND]() {
+		return true;
+	}
+	/**
+	* Serializa o erro para um objeto simples apropriado para `JSON.stringify`,
+	* logs ou transmissão. Veja {@link serializeBaseError} para os detalhes do
+	* formato retornado.
+	*
+	* @param includeStack - Se `true` inclui o stack trace no resultado (e na
+	* serialização de causas e parâmetros). Por padrão, `false`.
+	* @returns Representação serializável do erro.
+	*/
+	serialize(includeStack = false) {
+		return require_functions_index.serializeBaseError(this, includeStack);
+	}
+	/**
+	* Chamado automaticamente por `JSON.stringify`. Equivale a
+	* {@link BaseError.serialize} sem stack trace.
+	*
+	* @returns Representação serializável do erro sem stack trace.
+	*/
+	toJSON() {
+		return this.serialize();
+	}
+	/**
+	* Verifica se um valor é uma instância de `BaseError` (type guard).
+	*
+	* Atalho para {@link isBaseError}: usa a marca interna em vez de
+	* `instanceof` funcionando mesmo com múltiplas cópias do pacote.
+	*
+	* @param error - Valor a ser verificado.
+	* @returns `true` se `error` for um `BaseError`; caso contrário, `false`.
+	*/
+	static is(error) {
+		return require_functions_index.isBaseError(error);
+	}
+	/**
+	* Serializa de forma segura qualquer valor usado como causa de um erro.
+	*
+	* Atalho para {@link serializeCauseError}: trata erros, datas, arrays,
+	* objetos, funções, `bigint`, `symbol` e referências circulares.
+	*
+	* @param cause - Valor a ser serializado.
+	* @param includeStack - Se `true` inclui o stack trace ao serializar
+	* erros. Por padrão, `false`.
+	* @returns Representação serializável do valor.
+	*/
+	static serializeCauseError(cause, includeStack = false) {
+		return require_functions_index.serializeCauseError(cause, includeStack);
+	}
+};
+//#endregion
+//#region src/define-error-catalog.ts
+/**
+* Cria um catálogo de erros imutável a partir de um objeto que associa cada
+* código de erro à sua mensagem.
+*
+* Para cada entrada de `definitions` gera um {@link ErrorDescriptor} com
+* `code` e `message` congelado com `Object.freeze`. O próprio catálogo
+* retornado também é congelado, de modo que nem o catálogo nem seus
+* descritores podem ser alterados depois de criados.
+*
+* A validação ocorre em duas camadas:
+* - em tempo de compilação via {@link ValidateErrorDefinitions}: códigos fora
+*   de UPPER_SNAKE_CASE geram um erro de tipo com uma mensagem explicativa;
+* - em tempo de execução via {@link isUpperSnakeCase}: códigos inválidos
+*   lançam {@link InvalidErrorCode}, o que protege contra definições que
+*   escapem da checagem de tipos (ex.: objetos tipados como `any` ou
+*   `Record<string, string>`).
+*
+* O parâmetro de tipo `T` é declarado como `const`, o que preserva os tipos
+* literais dos códigos e das mensagens sem a necessidade de `as const` na
+* chamada.
+*
+* @template Codes - Objeto que mapeia códigos de erro para suas mensagens.
+* @param definitions - Definições do catálogo: chaves são os códigos em
+* UPPER_SNAKE_CASE.
+* @returns Catálogo de erros somente leitura com um descritor para cada
+* código informado.
+* @throws {InvalidErrorCode} Se algum código não estiver em UPPER_SNAKE_CASE.
+*
+* @example
+* ```ts
+* const TEST_ERROR_CODES = defineErrorCatalog({
+*   USER_NOT_FOUND: "Usuário {id} não encontrado",
+*   INVALID_TOKEN: "Token inválido",
+* });
+*
+* TEST_ERROR_CODES.USER_NOT_FOUND.code;    // "USER_NOT_FOUND"
+* TEST_ERROR_CODES.USER_NOT_FOUND.message; // "Usuário {id} não encontrado"
+*
+* // Erro de compilação (e de execução): código fora de UPPER_SNAKE_CASE
+* defineErrorCatalog({
+*   userNotFound: "Usuário não encontrado",
+* });
+* // Lança InvalidErrorCode
+* ```
+*/
+function defineErrorCatalog(definitions) {
+	const catalog = {};
+	for (const [code, message] of Object.entries(definitions)) {
+		if (!require_errors.isUpperSnakeCase(code)) throw new require_errors.InvalidErrorCode(code);
+		catalog[code] = Object.freeze({
+			code,
+			message
+		});
+	}
+	return Object.freeze(catalog);
+}
+//#endregion
+//#region src/either.ts
+/**
+* Representa o resultado de uma operação que pode ter sucesso (`Ok`) ou
+* falhar (`Err`), tornando o erro parte explícita do tipo de retorno em vez
+* de depender de exceções.
+*
+* Um `Either<O, E>` é sempre uma instância de {@link Ok} que carrega um
+* valor de sucesso do tipo `O`, ou de {@link Err} que carrega um valor de
+* erro do tipo `E`. Use {@link ok} e {@link err} para criá-los.
+*
+* Os métodos {@link Either.map}, {@link Either.mapErr}, {@link Either.flatMap}
+* e {@link Either.orElse} retornam um novo `Either` e não alteram o original.
+* Para tratar os dois casos use {@link Either.match}, ou os type guards
+* {@link Either.isOk} e {@link Either.isErr}.
+*
+* @template O - Tipo do valor de sucesso.
+* @template E - Tipo do valor de erro.
+*
+* @example
+* ```ts
+* function toDivide(a: number, b: number): Either<number, string> {
+*   return b === 0 ? err("Divisão por zero") : ok(a / b);
+* }
+*
+* const message = toDivide(10, 2)
+*   .map((resultado) => resultado * 3)
+*   .match({
+*     onOk: (valor) => `Resultado: ${valor}`,
+*     onErr: (erro) => `Falha: ${erro}`,
+*   });
+* // "Resultado: 15"
+* ```
+*/
+var Either = class {
+	/**
+	* Transforma o valor de sucesso mantendo o erro intacto.
+	*
+	* Se for `Ok` aplica `fn` ao valor e retorna um novo `Ok` com o resultado.
+	* Se for `Err` `fn` não é chamada e um novo `Err` com o mesmo erro é
+	* retornado. Exceções lançadas por `fn` não são capturadas.
+	*
+	* @template O2 - Tipo do novo valor de sucesso.
+	* @param fn - Função que converte o valor de sucesso.
+	* @returns Um `Either` com o valor transformado ou o erro original.
+	*
+	* @example
+	* ```ts
+	* ok<number, string>(2).map((n) => n * 2).unwrap(); // 4
+	* err<number, string>("falhou").map((n) => n * 2).unwrapErr(); // "falhou"
+	* ```
+	*/
+	map(fn) {
+		if (this.isOk()) return ok(fn(this.unwrap()));
+		return err(this.unwrapErr());
+	}
+	/**
+	* Transforma o valor de erro mantendo o sucesso intacto.
+	*
+	* Se for `Err` aplica `fn` ao erro e retorna um novo `Err` com o resultado.
+	* Se for `Ok` `fn` não é chamada e um novo `Ok` com o mesmo valor é
+	* retornado. Exceções lançadas por `fn` não são capturadas.
+	*
+	* @template E2 - Tipo do novo valor de erro.
+	* @param fn - Função que converte o valor de erro.
+	* @returns Um `Either` com o erro transformado ou o valor original.
+	*
+	* @example
+	* ```ts
+	* err<number, string>("falhou").mapErr((e) => e.length).unwrapErr(); // 7
+	* ok<number, string>(1).mapErr((e) => e.length).unwrap(); // 1
+	* ```
+	*/
+	mapErr(fn) {
+		if (this.isErr()) return err(fn(this.unwrapErr()));
+		return ok(this.unwrap());
+	}
+	/**
+	* Encadeia uma operação que também retorna um `Either` usada quando o
+	* próximo passo também pode falhar.
+	*
+	* Se for `Ok`, retorna diretamente o `Either` produzido por `fn` (sem
+	* aninhamento). Se for `Err` `fn` não é chamada e o erro é propagado.
+	* O tipo de erro resultante é a união `E | E2`. Exceções lançadas por `fn`
+	* não são capturadas.
+	*
+	* @template O2 - Tipo do valor de sucesso retornado por `fn`.
+	* @template E2 - Tipo do valor de erro retornado por `fn`.
+	* @param fn - Função que recebe o valor de sucesso e retorna um `Either`.
+	* @returns O `Either` retornado por `fn`, ou o erro original.
+	*
+	* @example
+	* ```ts
+	* const forNumber = (s: string): Either<number, string> => {
+	*   const n = Number(s);
+	*   return Number.isNaN(n) ? err("Não é número") : ok(n);
+	* };
+	*
+	* ok<string, string>("42").flatMap(forNumber).unwrap(); // 42
+	* ok<string, string>("abc").flatMap(forNumber).unwrapErr(); // "Não é número"
+	* ```
+	*/
+	flatMap(fn) {
+		if (this.isOk()) return fn(this.unwrap());
+		return err(this.unwrapErr());
+	}
+	/**
+	* Tenta se recuperar de um erro encadeando uma operação alternativa que
+	* também retorna um `Either`. É o oposto de {@link Either.flatMap}.
+	*
+	* Se for `Err` retorna diretamente o `Either` produzido por `fn`. Se for
+	* `Ok` `fn` não é chamada e o valor é mantido. O tipo de sucesso
+	* resultante é a união `O | O2`. Exceções lançadas por `fn` não são
+	* capturadas.
+	*
+	* @template O2 - Tipo do valor de sucesso retornado por `fn`.
+	* @template E2 - Tipo do valor de erro retornado por `fn`.
+	* @param fn - Função que recebe o valor de erro e retorna um `Either`.
+	* @returns O `Either` retornado por `fn`, ou o valor de sucesso original.
+	*
+	* @example
+	* ```ts
+	* err<number, string>("falhou").orElse(() => ok(0)).unwrap(); // 0
+	* ok<number, string>(5).orElse(() => ok(0)).unwrap(); // 5
+	* ```
+	*/
+	orElse(fn) {
+		if (this.isErr()) return fn(this.unwrapErr());
+		return ok(this.unwrap());
+	}
+	/**
+	* Trata os dois casos e produz um único valor chamando o handler da
+	* variante correspondente.
+	*
+	* @template R - Tipo do valor retornado pelos handlers.
+	* @param handlers - Objeto com `onOk` chamado com o valor de sucesso e
+	* `onErr` chamado com o valor de erro.
+	* @returns O resultado do handler chamado.
+	*
+	* @example
+	* ```ts
+	* const texto = resultado.match({
+	*   onOk: (valor) => `Sucesso: ${valor}`,
+	*   onErr: (erro) => `Erro: ${erro}`,
+	* });
+	* ```
+	*/
+	match(handlers) {
+		if (this.isOk()) return handlers.onOk(this.unwrap());
+		return handlers.onErr(this.unwrapErr());
+	}
+};
+/**
+* Variante de sucesso de {@link Either} que carrega um valor do tipo `O`.
+*
+* O construtor é `protected`; para criar uma instância use {@link Ok.create}
+* ou a função {@link ok}.
+*
+* @template O - Tipo do valor de sucesso. Por padrão, `never`.
+* @template E - Tipo do valor de erro usado apenas para compatibilidade com
+* {@link Either}. Por padrão, `never`.
+*/
+var Ok = class Ok extends Either {
+	/** Discriminante da variante sempre `"Ok"`. */
+	tag = "Ok";
+	/** Valor de sucesso armazenado. */
+	value;
+	/**
+	* @param value - Valor de sucesso a ser armazenado.
+	*/
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	/**
+	* Retorna o valor de sucesso armazenado.
+	*
+	* @returns O valor contido.
+	*/
+	unwrap() {
+		return this.value;
+	}
+	/**
+	* Sempre lança um erro pois um `Ok` não possui valor de erro.
+	*
+	* @throws {EitherUnwrapError} Sempre. A `cause` é o valor de sucesso contido.
+	*/
+	unwrapErr() {
+		throw new require_errors.EitherUnwrapError("Chamado unwrapErr() em Ok.", { cause: this.value });
+	}
+	/** @returns Sempre `true`. */
+	isOk() {
+		return true;
+	}
+	/** @returns Sempre `false`. */
+	isErr() {
+		return false;
+	}
+	/**
+	* Cria um `Ok` com o valor informado.
+	*
+	* @template O - Tipo do valor de sucesso. Por padrão, `never`.
+	* @template E - Tipo do valor de erro. Por padrão, `never`.
+	* @param value - Valor de sucesso.
+	* @returns Uma nova instância de `Ok`.
+	*/
+	static create(value) {
+		return new Ok(value);
+	}
+};
+/**
+* Variante de erro de {@link Either} que carrega um valor do tipo `E`.
+*
+* O construtor é `protected`; para criar uma instância use {@link Err.create}
+* ou a função {@link err}.
+*
+* @template O - Tipo do valor de sucesso usado apenas para compatibilidade
+* com {@link Either}. Por padrão, `never`.
+* @template E - Tipo do valor de erro. Por padrão, `never`.
+*/
+var Err = class Err extends Either {
+	/** Discriminante da variante sempre `"Err"`. */
+	tag = "Err";
+	/** Valor de erro armazenado. */
+	value;
+	/**
+	* @param value - Valor de erro a ser armazenado.
+	*/
+	constructor(value) {
+		super();
+		this.value = value;
+	}
+	/**
+	* Sempre lança um erro pois um `Err` não possui valor de sucesso.
+	*
+	* @throws {EitherUnwrapError} Sempre. A `cause` é o valor de erro contido.
+	*/
+	unwrap() {
+		throw new require_errors.EitherUnwrapError("Chamado unwrap() em Err.", { cause: this.value });
+	}
+	/**
+	* Retorna o valor de erro armazenado.
+	*
+	* @returns O valor contido.
+	*/
+	unwrapErr() {
+		return this.value;
+	}
+	/** @returns Sempre `false`. */
+	isOk() {
+		return false;
+	}
+	/** @returns Sempre `true`. */
+	isErr() {
+		return true;
+	}
+	/**
+	* Cria um `Err` com o valor informado.
+	*
+	* @template O - Tipo do valor de sucesso. Por padrão, `never`.
+	* @template E - Tipo do valor de erro. Por padrão, `never`.
+	* @param value - Valor de erro.
+	* @returns Uma nova instância de `Err`.
+	*/
+	static create(value) {
+		return new Err(value);
+	}
+};
+/**
+* Cria um {@link Either} de sucesso (`Ok`) com o valor informado.
+*
+* O retorno é tipado como `Either<O, E>` e não como `Ok` para que possa ser
+* usado onde se espera qualquer variante. Como `E` não pode ser inferido a
+* partir do argumento, informe-o explicitamente quando necessário.
+*
+* @template O - Tipo do valor de sucesso. Por padrão, `never`.
+* @template E - Tipo do valor de erro. Por padrão, `never`.
+* @param value - Valor de sucesso.
+* @returns Um `Either` que é um `Ok` contendo `value`.
+*
+* @example
+* ```ts
+* const result = ok<number, string>(42);
+* result.isOk();   // true
+* result.unwrap(); // 42
+* ```
+*/
+function ok(value) {
+	return Ok.create(value);
+}
+/**
+* Cria um {@link Either} de erro (`Err`) com o valor informado.
+*
+* O retorno é tipado como `Either<O, E>` e não como `Err` para que possa ser
+* usado onde se espera qualquer variante. Como `O` não pode ser inferido a
+* partir do argumento, informe-o explicitamente quando necessário.
+*
+* @template O - Tipo do valor de sucesso. Por padrão, `never`.
+* @template E - Tipo do valor de erro. Por padrão, `never`.
+* @param value - Valor de erro.
+* @returns Um `Either` que é um `Err` contendo `value`.
+*
+* @example
+* ```ts
+* const result = err<number, string>("Algo deu errado");
+* result.isErr();      // true
+* result.unwrapErr();  // "Algo deu errado"
+* ```
+*/
+function err(value) {
+	return Err.create(value);
+}
+//#endregion
+exports.BASE_ERROR_BRAND = require_functions_index.BASE_ERROR_BRAND;
+exports.BaseError = BaseError;
+exports.CIRCULAR_MARKER = require_functions_index.CIRCULAR_MARKER;
+exports.DEFAULT_PARAM_DELIMITERS = require_functions_index.DEFAULT_PARAM_DELIMITERS;
+exports.Either = Either;
+exports.EitherUnwrapError = require_errors.EitherUnwrapError;
+exports.Err = Err;
+exports.InvalidErrorCode = require_errors.InvalidErrorCode;
+exports.InvalidParamDelimitersError = require_invalid_param_delimiters_error.InvalidParamDelimitersError;
+exports.Ok = Ok;
+exports.UPPER_SNAKE_CASE = require_errors.UPPER_SNAKE_CASE;
+exports.createParamPlaceholder = require_functions_index.createParamPlaceholder;
+exports.defineErrorCatalog = defineErrorCatalog;
+exports.err = err;
+exports.escapeRegExp = require_functions_index.escapeRegExp;
+exports.interpolateErrorMessage = interpolateErrorMessage;
+exports.invalidCodeMessage = require_errors.invalidCodeMessage;
+exports.isBaseError = require_functions_index.isBaseError;
+exports.isUpperSnakeCase = require_errors.isUpperSnakeCase;
+exports.ok = ok;
+exports.serializeBaseError = require_functions_index.serializeBaseError;
+exports.serializeCauseError = require_functions_index.serializeCauseError;
+exports.serializeNativeError = require_functions_index.serializeNativeError;
+
+//# sourceMappingURL=index.cjs.map