makeNamedError(
  // Anonymous classes will be transformed into a named class by makeNamedError
  class extends Error {
    // ...
  },
  'MyCustomError'
);

makeNamedError(
  // However, for improved DX in TypeScript, give your class definitions names
  class MyCustomSubclassError extends MyCustomError {
    // ...
  },
  'MyCustomSubclassError'
);

const { MyCustomError } = makeNamedError(/* ... */, 'MyCustomError');

console.log(MyCustomError.name) // MyCustomError
console.log((new MyCustomError()).name) // MyCustomError

const { MyCoolError } = makeNamedError(/* ... */, 'MyCoolError');

console.log(MyCoolError.name) // MyCoolError (every time!)

const { BigError, isBigError } = makeNamedError(/* ... */, 'BigError');

console.log(isBigError(new BigError())) // true
console.log(isBigError(new SomeOtherError())) // false
console.log(isBigError(new Error())) // false

const { BigError } = makeNamedError(/* ... */, 'BigError');

console.log(BigError.isError(new BigError())); // true
console.log(BigError.isError(new SomeOtherError())); // false
console.log(BigError.isError(new Error())); // false

import lib1 from 'some-lib-exports-your-error';
import lib2 from 'unrelated-lib-also-exports-same-error-but-not-strictly-equal';

console.log(new lib1.YourError() instanceof lib2.YourError); // false
console.log(lib2.YourError.isError(new lib1.YourError())); // true

const { AppError } = makeNamedError(
  class AppError extends Error {
    panic() {
      console.log('oh no!');
      process.exit(123);
    }
  },
  'AppError'
);

const { ValidationError } = makeNamedError(
  // Note how ValidationError extends AppError
  class ValidationError extends AppError {
    #validationErrors: string[];

    constructor(issues: string[]) {
      super();
      this.#validationErrors = issues;
    }

    getValidationErrors() {
      return this.#validationErrors;
    }
  },
  'ValidationError'
);

const error = new ValidationError(['validation error 1', 'validation error 2']);

if (ValidationError.isError(error)) {
  console.log('validation errors:', error.getValidationErrors().join(', '));
  // validation errors: validation error 1, validation error 2
}

// Other logic...

if (AppError.isError(error)) {
  error.panic(); // This will run thanks to polymorphism and inheritance rules
}

// The program will die before reaching this point thanks to error.panic()

import {
  makeNamedError,
  isANamedErrorClass,
  isANamedErrorInstance
} from '@-xun/error';

const { SmallError, isSmallError } = makeNamedError(
  /* ... */, // All class methods and properties are preserved as expected
  'SmallError'
);

console.log(isANamedErrorClass(Error)); // false
console.log(isANamedErrorInstance(new Error())); // false
console.log(SmallError.isError(new Error())); // false
console.log(isSmallError(new Error())); // false

// All isX type guard functions will narrow unknown types properly!

console.log(isANamedErrorClass(SmallError)); // true
console.log(isANamedErrorInstance(new SmallError())); // true
console.log(SmallError.isError(new SmallError())); // true
console.log(isSmallError(new SmallError())); // true

import { makeNamedError } from '@-xun/error';

export const { AppError } = makeNamedError(
  class AppError extends Error {},
  'AppError'
);

export const { ValidationError } = makeNamedError(
  class ValidationError extends AppError {},
  'ValidationError'
);

export const { AuthError } = makeNamedError(
  class AuthError extends AppError {},
  'AuthError'
);

export const { NotFoundError } = makeNamedError(
  class NotFoundError extends AppError {},
  'NotFoundError'
);

// Improve TypeScript DX by exporting the literal class types too, if you want
export type ValidationError = InstanceType<typeof ValidationError>;
export type AuthError = InstanceType<typeof AuthError>;
export type NotFoundError = InstanceType<typeof NotFoundError>;

import { ValidationError } from './shared/errors.ts';

// ...

if (somethingBadHappened) {
  throw new ValidationError();
}

// ...