@nr1e/commons 0.1.1 → 0.1.3-alpha.0

package/src/bitsnbytes/b64.mts

@@ -1,158 +0,0 @@
-import {IllegalArgumentError} from '../errors/errors.mjs';
-
-// eslint-disable-next-line node/no-unsupported-features/node-builtins
-const encoder = new TextEncoder();
-// eslint-disable-next-line node/no-unsupported-features/node-builtins
-const decoder = new TextDecoder();
-
-export const BASE64_CHARS: Uint8Array = new Uint8Array([
-  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
-  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
-  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
-  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2b, 0x2f, 0x3d,
-]);
-// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/', '='
-
-export const URL_MODIFIED_BASE64_CHARS: Uint8Array = new Uint8Array([
-  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
-  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
-  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
-  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2d, 0x5f,
-]);
-// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '-', '_',
-
-export const YUI_BASE64_CHARS: Uint8Array = new Uint8Array([
-  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d,
-  0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5a,
-  0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d,
-  0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a,
-  0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2e, 0x5f, 0x2d,
-]);
-// 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-// 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-// 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-// 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-// '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '_', '-'
-
-export type Base64CharSet = 'b64' | 'url' | 'yui';
-
-export interface Base64Options {
-  readonly fromIndex?: number;
-  readonly toIndex?: number;
-  readonly b64chars?: Uint8Array | Base64CharSet;
-}
-
-/**
- * Returns a base64 character set and validates one if passed in.
- *
- * @param b64chars a base64 character set
- */
-export function b64Charset(b64chars?: Uint8Array | Base64CharSet): Uint8Array {
-  if (b64chars === undefined || b64chars === null) {
-    return BASE64_CHARS;
-  }
-  if (b64chars instanceof Uint8Array) {
-    if (b64chars.length !== 65 && b64chars.length !== 64) {
-      throw new IllegalArgumentError(
-        'b64chars',
-        'Base 64 character sets must be 64 or 65 characters.'
-      );
-    }
-    return b64chars;
-  }
-  switch (b64chars) {
-    case 'b64':
-      return BASE64_CHARS;
-    case 'url':
-      return URL_MODIFIED_BASE64_CHARS;
-    case 'yui':
-      return YUI_BASE64_CHARS;
-    default:
-      throw new IllegalArgumentError(
-        'b64chars',
-        `Invalid base64 character set '${b64chars}'`
-      );
-  }
-}
-
-/**
- * Base64 encodes a series of bytes.
- *
- * @param buf Bytes to encode
- * @param opts Encoding options
- * @return a base64 string
- */
-export function tob64(buf: Uint8Array, opts?: Base64Options): Uint8Array {
-  const b64chars = b64Charset(opts?.b64chars);
-  const toIndex = opts?.toIndex ?? buf.length;
-  const fromIndex = opts?.fromIndex ?? 0;
-  // every 3 bytes is 4 characters in padded base64 (6 bits per char)
-  const num = toIndex - fromIndex;
-  const numc =
-    b64chars.length === 65
-      ? ((num + 2 - ((num + 2) % 3)) / 3) * 4 // padded
-      : (num * 8) / 6 + ((num * 8) % 6 !== 0 ? 1 : 0); // not padded
-  const b64 = new Uint8Array(numc);
-  let n = 0;
-  for (let i = 0; i < toIndex; i += 3) {
-    const v =
-      ((buf[i] & 0xff) << 16) |
-      (i + 1 < toIndex ? (buf[i + 1] & 0xff) << 8 : 0) |
-      (i + 2 < toIndex ? buf[i + 2] & 0xff : 0);
-    b64[n++] = b64chars[(v >>> 18) & 0x3f];
-    b64[n++] = b64chars[(v >>> 12) & 0x3f];
-    switch (
-      toIndex - i // calculate bytes remaining to be processed
-    ) {
-      case 1: // 0 bytes left to process
-        if (b64chars.length === 65) {
-          b64[n++] = b64chars[64];
-          b64[n++] = b64chars[64];
-        }
-        break;
-      case 2: // 1 byte left to process
-        b64[n++] = b64chars[(v >>> 6) & 0x3f];
-        if (b64chars.length === 65) {
-          b64[n++] = b64chars[64];
-        }
-        break;
-      default:
-        b64[n++] = b64chars[(v >>> 6) & 0x3f];
-        b64[n++] = b64chars[v & 0x3f];
-        break;
-    }
-  }
-  return b64;
-}
-
-/**
- * Base64 encodes a series of bytes to a string.
- *
- * @param buf Bytes to encode
- * @param opts Encoding options
- * @return a base64 string
- */
-export function tob64s(buf: Uint8Array, opts?: Base64Options): string {
-  return decoder.decode(tob64(buf, opts));
-}
-
-/**
- * Base64 encodes a string to a string.
- *
- * @param str String to encode
- * @param opts Encoding options
- * @return a base64 string
- */
-export function stob64s(str: string, opts?: Base64Options): string {
-  return tob64s(encoder.encode(str), opts);
-}

package/src/bitsnbytes/b64.test.mts

@@ -1,78 +0,0 @@
-import {test, expect} from 'vitest';
-import {stob64s, tob64s} from './b64.mjs';
-import * as crypto from 'crypto';
-
-test('Test tob64', () => {
-  const str = '"Computer, compute to the last digit the value of pi" -- Spock';
-  let b64s = [
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s=',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw==',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A=',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw==',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0=',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ==',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI=',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ==',
-  ];
-  for (let i = 0; i < b64s.length; i++) {
-    expect(b64s[i]).toBe(stob64s(str.substring(0, str.length - i)));
-  }
-
-  // Test URL modified base64 encoding
-  b64s = [
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ',
-  ];
-  for (let i = 0; i < b64s.length; i++) {
-    expect(b64s[i]).toBe(
-      stob64s(str.substring(0, str.length - i), {b64chars: 'url'})
-    );
-  }
-
-  // Test YUI modified base64 encoding
-  b64s = [
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvY2s-',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3BvYw--',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3Bv',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gU3A-',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0gUw--',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0g',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLS0-',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIgLQ--',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSIg',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaSI-',
-    'IkNvbXB1dGVyLCBjb21wdXRlIHRvIHRoZSBsYXN0IGRpZ2l0IHRoZSB2YWx1ZSBvZiBwaQ--',
-  ];
-  for (let i = 0; i < b64s.length; i++) {
-    expect(b64s[i]).toBe(
-      stob64s(str.substring(0, str.length - i), {b64chars: 'yui'})
-    );
-  }
-});
-
-test('Compare to Node', () => {
-  for (let i = 0; i < 100; i++) {
-    const bytes = crypto.randomBytes(16);
-    const str = tob64s(bytes, {b64chars: 'url'});
-    const nodeStr = bytes.toString('base64url');
-    expect(str).toEqual(nodeStr);
-  }
-  for (let i = 0; i < 100; i++) {
-    const bytes = crypto.randomBytes(16);
-    const str = tob64s(bytes, {b64chars: 'b64'});
-    const nodeStr = bytes.toString('base64');
-    expect(str).toEqual(nodeStr);
-  }
-});

package/src/bitsnbytes/index.mts

@@ -1 +0,0 @@
-export * from './b64.mjs';

package/src/errors/errors.mts

@@ -1,271 +0,0 @@
-import {HttpStatusCode} from '../http/index.mjs';
-import {isError, isObject} from '../lang/index.mjs';
-
-/**
- * An extended version of Error that includes an HttpStatusCode.
- * This can be useful in middleware error handlers to determine http status codes to return to the client.
- */
-export interface HttpError extends Error {
-  /**
-   * The HTTP status code.
-   */
-  statusCode: HttpStatusCode | number;
-}
-
-/**
- * Checks if the given parameter is an HttpError.
- *
- * @param e The parameter to check
- */
-export function isHttpError(e?: unknown): e is HttpError {
-  return isObject(e) && !!(e && e.stack && e.statusCode && e.message && e.name);
-}
-
-/**
- * Thrown when a resource cannot be found.
- */
-export class NotFoundError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.NOT_FOUND;
-  /**
-   * The max-age value to set in the Cache-Control header if used in a middleware.
-   */
-  readonly maxAge?: number;
-  constructor(message?: string, maxAge?: number) {
-    message = message ?? 'Not found';
-    super(message);
-    this.name = 'NotFoundError';
-    this.maxAge = maxAge;
-  }
-}
-
-/**
- * Checks if the given parameter is a NotFoundError.
- *
- * @param e The parameter to check
- */
-export function isNotFoundError(e?: unknown): e is NotFoundError {
-  return isHttpError(e) && e.name === 'NotFoundError';
-}
-
-/**
- * Thrown when a request is missing authentication credentials.
- */
-export class UnauthorizedError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.UNAUTHORIZED;
-  constructor(message?: string) {
-    message = message ?? 'Unauthorized';
-    super(message);
-    this.name = 'UnauthorizedError';
-  }
-}
-
-/**
- * Checks if the given parameter is a UnauthorizedError.
- *
- * @param e The parameter to check
- */
-export function isUnauthorizedError(e?: unknown): e is UnauthorizedError {
-  return isHttpError(e) && e.name === 'UnauthorizedError';
-}
-
-/**
- * Thrown when credentials are present, but the requested operations is not allowed.
- */
-export class ForbiddenError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.FORBIDDEN;
-  constructor(message?: string) {
-    message = message ?? 'Forbidden';
-    super(message);
-    this.name = 'ForbiddenError';
-  }
-}
-
-/**
- * Checks if the given parameter is a ForbiddenError.
- *
- * @param e The parameter to check
- */
-export function isForbiddenError(e?: unknown): e is ForbiddenError {
-  return isHttpError(e) && e.name === 'ForbiddenError';
-}
-
-/**
- * Thrown when a validation error occurs.
- */
-export class ValidationError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.BAD_REQUEST;
-  constructor(message?: string) {
-    message = message ?? 'Validation error';
-    super(message);
-    this.name = 'ValidationError';
-  }
-}
-
-/**
- * Checks if the given variable is a ValidationError.
- *
- * @param e The variable to check
- */
-export function isValidationError(e?: unknown): e is ValidationError {
-  return isHttpError(e) && e.name === 'ValidationError';
-}
-
-/**
- * Thrown when a bad request is made.
- */
-export class BadRequestError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.BAD_REQUEST;
-  constructor(message?: string) {
-    message = message ?? 'Bad request';
-    super(message ?? 'Bad request');
-    this.name = 'BadRequestError';
-  }
-}
-
-/**
- * Checks if the given parameter is a BadRequestError.
- *
- * @param e The parameter to check
- */
-export function isBadRequestError(e?: unknown): e is BadRequestError {
-  return isHttpError(e) && e.name === 'BadRequestError';
-}
-
-/**
- * Throws when an internal server error occurs.
- */
-export class InternalServerError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.INTERNAL_SERVER_ERROR;
-  constructor(message?: string) {
-    message = message ?? 'Internal server error';
-    super(message);
-    this.name = 'InternalServerError';
-  }
-}
-
-/**
- * Checks if the given parameter is a InternalServerError.
- *
- * @param e The parameter to check
- */
-export function isInternalServerError(e?: unknown): e is InternalServerError {
-  return isHttpError(e) && e.name === 'InternalServerError';
-}
-
-/**
- * Thrown when a conflict occurs.
- */
-export class ConflictError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.CONFLICT;
-  constructor(message?: string) {
-    message = message ?? 'Conflict';
-    super(message);
-    this.name = 'ConflictError';
-  }
-}
-
-/**
- * Checks if the given parameter is a ConflictError.
- *
- * @param e The parameter to check
- */
-export function isConflictError(e?: unknown): e is ConflictError {
-  return isHttpError(e) && e.name === 'ConflictError';
-}
-
-/**
- * Thrown when a unsupported media type is used.
- */
-export class UnsupportedMediaTypeError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.UNSUPPORTED_MEDIA_TYPE;
-  constructor(message?: string) {
-    message = message ?? 'Unsupported media type';
-    super(message);
-    this.name = 'UnsupportedMediaTypeError';
-  }
-}
-
-/**
- * Checks if the given parameter is a UnsupportedMediaTypeError.
- *
- * @param e The parameter to check
- */
-export function isUnsupportedMediaTypeError(
-  e?: unknown
-): e is UnsupportedMediaTypeError {
-  return isHttpError(e) && e.name === 'UnsupportedMediaTypeError';
-}
-
-/**
- * Thrown when a requested operation is not implemented.
- */
-export class NotImplementedError extends Error implements HttpError {
-  readonly statusCode = HttpStatusCode.NOT_IMPLEMENTED;
-  readonly expose = true;
-  constructor(message?: string) {
-    message = message ?? 'Not implemented';
-    super(message);
-    this.name = 'NotImplementedError';
-  }
-}
-
-/**
- * Checks if the given parameter is a NotImplementedError.
- *
- * @param e The parameter to check
- */
-export function isNotImplementedError(e?: unknown): e is NotImplementedError {
-  return isHttpError(e) && e.name === 'NotImplementedError';
-}
-
-/**
- * Thrown when an illegal argument is passed to a function.
- */
-export class IllegalArgumentError extends Error {
-  readonly argName: string;
-  constructor(argName: string, message?: string) {
-    message = message ?? `Illegal argument ${argName}`;
-    super(message);
-    this.argName = argName;
-    this.name = 'IllegalArgumentError';
-  }
-}
-
-/**
- * Checks if the given parameter is a IllegalArgumentError.
- *
- * @param e The parameter to check
- */
-export function isIllegalArgumentError(e?: unknown): e is IllegalArgumentError {
-  return isError(e) && e.name === 'IllegalArgumentError';
-}
-
-/**
- * Converts the given parameter to an HttpError.
- *
- * @param code The HTTP status code
- * @param message The error message
- */
-export function toError(
-  code: number | HttpStatusCode,
-  message?: string
-): Error {
-  switch (code) {
-    case HttpStatusCode.NOT_FOUND:
-      return new NotFoundError(message);
-    case HttpStatusCode.FORBIDDEN:
-      return new ForbiddenError(message);
-    case HttpStatusCode.BAD_REQUEST:
-      return new BadRequestError(message);
-    case HttpStatusCode.INTERNAL_SERVER_ERROR:
-      return new InternalServerError(message);
-    case HttpStatusCode.CONFLICT:
-      return new ConflictError(message);
-    case HttpStatusCode.UNSUPPORTED_MEDIA_TYPE:
-      return new UnsupportedMediaTypeError(message);
-    case HttpStatusCode.NOT_IMPLEMENTED:
-      return new NotImplementedError(message);
-    default:
-      return new Error(message);
-  }
-}

package/src/errors/errors.test.mts

@@ -1,74 +0,0 @@
-import {test, expect} from 'vitest';
-import {
-  BadRequestError,
-  ForbiddenError,
-  InternalServerError,
-  isBadRequestError,
-  isForbiddenError,
-  isInternalServerError,
-  isNotFoundError,
-  isValidationError,
-  NotFoundError,
-  toError,
-  ValidationError,
-} from './errors.mjs';
-import {HttpStatusCode} from '../http/index.mjs';
-
-test('Test isNotFoundError', () => {
-  expect(isNotFoundError(undefined)).toBeFalsy();
-  expect(isNotFoundError(null)).toBeFalsy();
-  expect(isNotFoundError({})).toBeFalsy();
-  expect(isNotFoundError(new ForbiddenError('just a test'))).toBeFalsy();
-  expect(isNotFoundError(new NotFoundError('just a test'))).toBeTruthy();
-});
-
-test('Test isForbiddenError', () => {
-  expect(isForbiddenError(undefined)).toBeFalsy();
-  expect(isForbiddenError(null)).toBeFalsy();
-  expect(isForbiddenError({})).toBeFalsy();
-  expect(isForbiddenError(new NotFoundError('just a test'))).toBeFalsy();
-  expect(isForbiddenError(new ForbiddenError('just a test'))).toBeTruthy();
-});
-
-test('Test isValidationError', () => {
-  expect(isValidationError(undefined)).toBeFalsy();
-  expect(isValidationError(null)).toBeFalsy();
-  expect(isValidationError({})).toBeFalsy();
-  expect(isValidationError(new NotFoundError('just a test'))).toBeFalsy();
-  expect(isValidationError(new ValidationError('just a test'))).toBeTruthy();
-});
-
-test('Test isBadRequestError', () => {
-  expect(isBadRequestError(undefined)).toBeFalsy();
-  expect(isBadRequestError(null)).toBeFalsy();
-  expect(isBadRequestError({})).toBeFalsy();
-  expect(isBadRequestError(new NotFoundError('just a test'))).toBeFalsy();
-  expect(isBadRequestError(new BadRequestError('just a test'))).toBeTruthy();
-});
-
-test('Test isInternalServerError', () => {
-  expect(isInternalServerError(undefined)).toBeFalsy();
-  expect(isInternalServerError(null)).toBeFalsy();
-  expect(isInternalServerError({})).toBeFalsy();
-  expect(isInternalServerError(new NotFoundError('just a test'))).toBeFalsy();
-  expect(
-    isInternalServerError(new InternalServerError('just a test'))
-  ).toBeTruthy();
-});
-
-test('Test toError', () => {
-  expect(
-    isNotFoundError(toError(HttpStatusCode.NOT_FOUND, 'some message'))
-  ).toBeTruthy();
-  expect(
-    isForbiddenError(toError(HttpStatusCode.FORBIDDEN, 'some message'))
-  ).toBeTruthy();
-  expect(
-    isBadRequestError(toError(HttpStatusCode.BAD_REQUEST, 'some message'))
-  ).toBeTruthy();
-  expect(
-    isInternalServerError(
-      toError(HttpStatusCode.INTERNAL_SERVER_ERROR, 'some message')
-    )
-  ).toBeTruthy();
-});

package/src/errors/index.mts

@@ -1 +0,0 @@
-export * from './errors.mjs';

package/src/http/http-method.mts

@@ -1,9 +0,0 @@
-export enum HttpMethod {
-  GET = 'GET',
-  POST = 'POST',
-  PUT = 'PUT',
-  PATCH = 'PATCH',
-  DELETE = 'DELETE',
-  HEAD = 'HEAD',
-  OPTIONS = 'OPTIONS',
-}

package/src/http/http-status-code.mts

@@ -1,42 +0,0 @@
-export enum HttpStatusCode {
-  CONTINUE = 100,
-  SWITCHING_PROTOCOLS = 101,
-  OK = 200,
-  CREATED = 201,
-  ACCEPTED = 202,
-  NON_AUTHORITATIVE_INFORMATION = 203,
-  NO_CONTENT = 204,
-  RESET_CONTENT = 205,
-  PARTIAL_CONTENT = 206,
-  MULTIPLE_CHOICES = 300,
-  PERMANENT_REDIRECT = 301,
-  FOUND = 302,
-  SEE_OTHER = 303,
-  NOT_MODIFIED = 304,
-  USE_PROXY = 305,
-  TEMPORARY_REDIRECT = 307,
-  BAD_REQUEST = 400,
-  UNAUTHORIZED = 401,
-  PAYMENT_REQUIRED = 402,
-  FORBIDDEN = 403,
-  NOT_FOUND = 404,
-  METHOD_NOT_ALLOWED = 405,
-  NOT_ACCEPTABLE = 406,
-  PROXY_AUTHENTICATION_REQUIRED = 407,
-  REQUEST_TIMEOUT = 408,
-  CONFLICT = 409,
-  GONE = 410,
-  LENGTH_REQUIRED = 411,
-  PRECONDITION_FAILED = 412,
-  REQUEST_ENTITY_TOO_LARGE = 413,
-  REQUEST_URI_TOO_LONG = 414,
-  UNSUPPORTED_MEDIA_TYPE = 415,
-  RANGE_NOT_SATISFIABLE = 416,
-  EXPECTATION_FAILED = 417,
-  INTERNAL_SERVER_ERROR = 500,
-  NOT_IMPLEMENTED = 501,
-  BAD_GATEWAY = 502,
-  SERVICE_UNAVAILABLE = 503,
-  GATEWAY_TIMEOUT = 504,
-  HTTP_VERSION_NOT_SUPPORTED = 505,
-}

package/src/http/index.mts

@@ -1,2 +0,0 @@
-export * from './http-status-code.mjs';
-export * from './http-method.mjs';

package/src/lang/index.mts

@@ -1,2 +0,0 @@
-export * from './type-functions.mjs';
-export * from './sleep.mjs';

package/src/lang/sleep.mts

@@ -1,8 +0,0 @@
-/**
- * Sleep for a given amount of time
- *
- * @param ms the number of milliseconds to sleep
- */
-export function sleep(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}

package/src/lang/type-functions.mts

@@ -1,13 +0,0 @@
-export function isObject(item: unknown): item is Record<string, unknown> {
-  return (
-    item !== null && typeof item === 'object' && Array.isArray(item) === false
-  );
-}
-
-export function isString(item: unknown): item is string {
-  return typeof item === 'string';
-}
-
-export function isError(item: unknown): item is Error {
-  return item instanceof Error;
-}