@tstdl/base 0.86.0-beta1 → 0.86.0-beta10

package/error/custom.error.js

@@ -1,29 +1,51 @@
-export class CustomError extends Error {
-    constructor(options = {}) {
-        if (options.fast == true) {
-            const errorObject = {};
-            init(errorObject, new.target, options);
-            // eslint-disable-next-line no-constructor-return
-            return errorObject;
-        }
-        const errorOptions = {};
-        if (options.cause != undefined) {
-            errorOptions.cause = options.cause;
-        }
-        super(options.message, errorOptions);
-        init(this, new.target, options);
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var custom_error_exports = {};
+__export(custom_error_exports, {
+  CustomError: () => CustomError
+});
+module.exports = __toCommonJS(custom_error_exports);
+class CustomError extends Error {
+  constructor(options = {}) {
+    if (options.fast == true) {
+      const errorObject = {};
+      init(errorObject, new.target, options);
+      return errorObject;
     }
+    const errorOptions = {};
+    if (options.cause != void 0) {
+      errorOptions.cause = options.cause;
+    }
+    super(options.message, errorOptions);
+    init(this, new.target, options);
+  }
 }
 function init(instance, target, { name, message, stack, cause, fast }) {
-    instance.message = instance.message ?? message ?? 'No error message provided.';
-    instance.name = name ?? target?.errorName ?? target.prototype.name;
-    if (stack != undefined) {
-        instance.stack = stack;
-    }
-    if ((cause != undefined) && (instance.cause == undefined)) {
-        instance.cause = cause;
-    }
-    if (fast == true) {
-        Object.setPrototypeOf(instance, target.prototype);
-    }
+  instance.message = instance.message ?? message ?? "No error message provided.";
+  instance.name = name ?? target?.errorName ?? target.prototype.name;
+  if (stack != void 0) {
+    instance.stack = stack;
+  }
+  if (cause != void 0 && instance.cause == void 0) {
+    instance.cause = cause;
+  }
+  if (fast == true) {
+    Object.setPrototypeOf(instance, target.prototype);
+  }
 }

package/error/details.error.js

@@ -1,9 +1,32 @@
-import { CustomError } from './custom.error.js';
-export class DetailsError extends CustomError {
-    static errorName = 'DetailsError';
-    details;
-    constructor(message, details) {
-        super({ message });
-        this.details = details;
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var details_error_exports = {};
+__export(details_error_exports, {
+  DetailsError: () => DetailsError
+});
+module.exports = __toCommonJS(details_error_exports);
+var import_custom_error = require("./custom.error.js");
+class DetailsError extends import_custom_error.CustomError {
+  static errorName = "DetailsError";
+  details;
+  constructor(message, details) {
+    super({ message });
+    this.details = details;
+  }
 }

package/error/forbidden.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class ForbiddenError extends CustomError {
-    static errorName = 'ForbiddenError';
-    constructor(message = 'forbidden') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var forbidden_error_exports = {};
+__export(forbidden_error_exports, {
+  ForbiddenError: () => ForbiddenError
+});
+module.exports = __toCommonJS(forbidden_error_exports);
+var import_custom_error = require("./custom.error.js");
+class ForbiddenError extends import_custom_error.CustomError {
+  static errorName = "ForbiddenError";
+  constructor(message = "forbidden") {
+    super({ message });
+  }
 }

package/error/index.js

@@ -1,16 +1,33 @@
-export * from './api.error.js';
-export * from './assertion.error.js';
-export * from './bad-request.error.js';
-export * from './custom.error.js';
-export * from './details.error.js';
-export * from './forbidden.error.js';
-export * from './invalid-token.error.js';
-export * from './max-bytes-exceeded.error.js';
-export * from './method-not-allowed.error.js';
-export * from './multi.error.js';
-export * from './not-found.error.js';
-export * from './not-implemented.error.js';
-export * from './not-supported.error.js';
-export * from './timeout.error.js';
-export * from './unauthorized.error.js';
-export * from './unsupported-media-type.error.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+module.exports = __toCommonJS(error_exports);
+__reExport(error_exports, require("./api.error.js"), module.exports);
+__reExport(error_exports, require("./assertion.error.js"), module.exports);
+__reExport(error_exports, require("./bad-request.error.js"), module.exports);
+__reExport(error_exports, require("./custom.error.js"), module.exports);
+__reExport(error_exports, require("./details.error.js"), module.exports);
+__reExport(error_exports, require("./forbidden.error.js"), module.exports);
+__reExport(error_exports, require("./invalid-token.error.js"), module.exports);
+__reExport(error_exports, require("./max-bytes-exceeded.error.js"), module.exports);
+__reExport(error_exports, require("./method-not-allowed.error.js"), module.exports);
+__reExport(error_exports, require("./multi.error.js"), module.exports);
+__reExport(error_exports, require("./not-found.error.js"), module.exports);
+__reExport(error_exports, require("./not-implemented.error.js"), module.exports);
+__reExport(error_exports, require("./not-supported.error.js"), module.exports);
+__reExport(error_exports, require("./timeout.error.js"), module.exports);
+__reExport(error_exports, require("./unauthorized.error.js"), module.exports);
+__reExport(error_exports, require("./unsupported-media-type.error.js"), module.exports);

package/error/invalid-token.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class InvalidTokenError extends CustomError {
-    static errorName = 'InvalidTokenError';
-    constructor(message = 'invalid token') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var invalid_token_error_exports = {};
+__export(invalid_token_error_exports, {
+  InvalidTokenError: () => InvalidTokenError
+});
+module.exports = __toCommonJS(invalid_token_error_exports);
+var import_custom_error = require("./custom.error.js");
+class InvalidTokenError extends import_custom_error.CustomError {
+  static errorName = "InvalidTokenError";
+  constructor(message = "invalid token") {
+    super({ message });
+  }
 }

package/error/max-bytes-exceeded.error.js

@@ -1,10 +1,33 @@
-import { CustomError } from './custom.error.js';
-export class MaxBytesExceededError extends CustomError {
-    static errorName = 'MaxBytesExceededError';
-    constructor(message = 'max bytes exceeded') {
-        super({ message });
-    }
-    static fromBytes(bytes) {
-        return new MaxBytesExceededError(`Maximum bytes of ${bytes} exceeded.`);
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var max_bytes_exceeded_error_exports = {};
+__export(max_bytes_exceeded_error_exports, {
+  MaxBytesExceededError: () => MaxBytesExceededError
+});
+module.exports = __toCommonJS(max_bytes_exceeded_error_exports);
+var import_custom_error = require("./custom.error.js");
+class MaxBytesExceededError extends import_custom_error.CustomError {
+  static errorName = "MaxBytesExceededError";
+  constructor(message = "max bytes exceeded") {
+    super({ message });
+  }
+  static fromBytes(bytes) {
+    return new MaxBytesExceededError(`Maximum bytes of ${bytes} exceeded.`);
+  }
 }

package/error/method-not-allowed.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class MethodNotAllowedError extends CustomError {
-    static errorName = 'MethodNotAllowedError';
-    constructor(message = 'method not allowed') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var method_not_allowed_error_exports = {};
+__export(method_not_allowed_error_exports, {
+  MethodNotAllowedError: () => MethodNotAllowedError
+});
+module.exports = __toCommonJS(method_not_allowed_error_exports);
+var import_custom_error = require("./custom.error.js");
+class MethodNotAllowedError extends import_custom_error.CustomError {
+  static errorName = "MethodNotAllowedError";
+  constructor(message = "method not allowed") {
+    super({ message });
+  }
 }

package/error/multi.error.js

@@ -1,9 +1,32 @@
-import { CustomError } from './custom.error.js';
-export class MultiError extends CustomError {
-    static errorName = 'MultiError';
-    errors;
-    constructor(errors, message = 'multiple errors occurred') {
-        super({ message });
-        this.errors = errors;
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var multi_error_exports = {};
+__export(multi_error_exports, {
+  MultiError: () => MultiError
+});
+module.exports = __toCommonJS(multi_error_exports);
+var import_custom_error = require("./custom.error.js");
+class MultiError extends import_custom_error.CustomError {
+  static errorName = "MultiError";
+  errors;
+  constructor(errors, message = "multiple errors occurred") {
+    super({ message });
+    this.errors = errors;
+  }
 }

package/error/not-found.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class NotFoundError extends CustomError {
-    static errorName = 'NotFoundError';
-    constructor(message = 'not found') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var not_found_error_exports = {};
+__export(not_found_error_exports, {
+  NotFoundError: () => NotFoundError
+});
+module.exports = __toCommonJS(not_found_error_exports);
+var import_custom_error = require("./custom.error.js");
+class NotFoundError extends import_custom_error.CustomError {
+  static errorName = "NotFoundError";
+  constructor(message = "not found") {
+    super({ message });
+  }
 }

package/error/not-implemented.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class NotImplementedError extends CustomError {
-    static errorName = 'NotImplementedError';
-    constructor(message = 'Not implemented.') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var not_implemented_error_exports = {};
+__export(not_implemented_error_exports, {
+  NotImplementedError: () => NotImplementedError
+});
+module.exports = __toCommonJS(not_implemented_error_exports);
+var import_custom_error = require("./custom.error.js");
+class NotImplementedError extends import_custom_error.CustomError {
+  static errorName = "NotImplementedError";
+  constructor(message = "Not implemented.") {
+    super({ message });
+  }
 }

package/error/not-supported.error.js

@@ -1,12 +1,35 @@
-import { enumValueName } from '../utils/enum.js';
-import { CustomError } from './custom.error.js';
-export class NotSupportedError extends CustomError {
-    static errorName = 'NotSupportedError';
-    constructor(message = 'Not supported.') {
-        super({ message });
-    }
-    static fromEnum(enumeration, name, value) {
-        const valueName = enumValueName(enumeration, value);
-        return new NotSupportedError(`${name} "${valueName}" is not supported.`);
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var not_supported_error_exports = {};
+__export(not_supported_error_exports, {
+  NotSupportedError: () => NotSupportedError
+});
+module.exports = __toCommonJS(not_supported_error_exports);
+var import_enum = require("../utils/enum.js");
+var import_custom_error = require("./custom.error.js");
+class NotSupportedError extends import_custom_error.CustomError {
+  static errorName = "NotSupportedError";
+  constructor(message = "Not supported.") {
+    super({ message });
+  }
+  static fromEnum(enumeration, name, value) {
+    const valueName = (0, import_enum.enumValueName)(enumeration, value);
+    return new NotSupportedError(`${name} "${valueName}" is not supported.`);
+  }
 }

package/error/timeout.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class TimeoutError extends CustomError {
-    static errorName = 'TimeoutError';
-    constructor(message = 'Operation timed out.') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var timeout_error_exports = {};
+__export(timeout_error_exports, {
+  TimeoutError: () => TimeoutError
+});
+module.exports = __toCommonJS(timeout_error_exports);
+var import_custom_error = require("./custom.error.js");
+class TimeoutError extends import_custom_error.CustomError {
+  static errorName = "TimeoutError";
+  constructor(message = "Operation timed out.") {
+    super({ message });
+  }
 }

package/error/unauthorized.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class UnauthorizedError extends CustomError {
-    static errorName = 'UnauthorizedError';
-    constructor(message = 'Unauthorized') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unauthorized_error_exports = {};
+__export(unauthorized_error_exports, {
+  UnauthorizedError: () => UnauthorizedError
+});
+module.exports = __toCommonJS(unauthorized_error_exports);
+var import_custom_error = require("./custom.error.js");
+class UnauthorizedError extends import_custom_error.CustomError {
+  static errorName = "UnauthorizedError";
+  constructor(message = "Unauthorized") {
+    super({ message });
+  }
 }

package/error/unsupported-media-type.error.js

@@ -1,7 +1,30 @@
-import { CustomError } from './custom.error.js';
-export class UnsupportedMediaTypeError extends CustomError {
-    static errorName = 'UnsupportedMediaTypeError';
-    constructor(message = 'Unsupported media type.') {
-        super({ message });
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var unsupported_media_type_error_exports = {};
+__export(unsupported_media_type_error_exports, {
+  UnsupportedMediaTypeError: () => UnsupportedMediaTypeError
+});
+module.exports = __toCommonJS(unsupported_media_type_error_exports);
+var import_custom_error = require("./custom.error.js");
+class UnsupportedMediaTypeError extends import_custom_error.CustomError {
+  static errorName = "UnsupportedMediaTypeError";
+  constructor(message = "Unsupported media type.") {
+    super({ message });
+  }
 }