@tstdl/base 0.83.0-beta2 → 0.83.0-beta4

package/enumerable/enumerable.js

@@ -1,179 +1,201 @@
-import { all, any, assert, batch, concat, defaultIfEmpty, deferredIterable, difference, differenceMany, distinct, drain, filter, first, firstOrDefault, forEach, group, groupSingle, groupToMap, groupToSingleMap, includes, last, lastOrDefault, map, mapMany, materialize, metadata, pairwise, range, reduce, single, singleOrDefault, skip, sort, take, takeUntil, takeWhile, tap, whileSync } from '../utils/iterable-helpers/index.js';
-import { isNotNullOrUndefined } from '../utils/type-guards.js';
-import { AsyncEnumerable } from './async-enumerable.js';
-export class Enumerable {
-    source;
-    constructor(iterable) {
-        this.source = iterable;
-    }
-    static from(source) {
-        return new Enumerable(source);
-    }
-    static fromDeferred(source) {
-        const deferred = deferredIterable(source);
-        return new Enumerable(deferred);
-    }
-    static fromRange(fromInclusive, toInclusive) {
-        const rangeIterable = range(fromInclusive, toInclusive);
-        return new Enumerable(rangeIterable);
-    }
-    assert(predicate) {
-        const asserted = assert(this.source, predicate);
-        return new Enumerable(asserted);
-    }
-    all(predicate) {
-        return all(this.source, predicate);
-    }
-    any(predicate) {
-        return any(this.source, predicate);
-    }
-    batch(size) {
-        const batched = batch(this.source, size);
-        return new Enumerable(batched);
-    }
-    cast() {
-        return this;
-    }
-    concat(...iterables) {
-        const concatted = concat(this.source, ...iterables);
-        return new Enumerable(concatted);
-    }
-    defaultIfEmpty(defaultValue) {
-        const result = defaultIfEmpty(this.source, defaultValue);
-        return new Enumerable(result);
-    }
-    difference(iterable, selector) {
-        const result = difference(this.source, iterable, selector);
-        return new Enumerable(result);
-    }
-    differenceMany(iterables, selector) {
-        const result = differenceMany(this.source, iterables, selector);
-        return new Enumerable(result);
-    }
-    distinct(selector) {
-        const result = distinct(this.source, selector);
-        return new Enumerable(result);
-    }
-    includes(value) {
-        return includes(this.source, value);
-    }
-    drain() {
-        drain(this.source);
-    }
-    filter(predicate) {
-        const filtered = filter(this.source, predicate);
-        return new Enumerable(filtered);
-    }
-    filterNullOrUndefined() {
-        return this.filter((item) => isNotNullOrUndefined(item));
-    }
-    first(predicate) {
-        return first(this.source, predicate);
-    }
-    firstOrDefault(defaultValue, predicate) {
-        return firstOrDefault(this.source, defaultValue, predicate);
-    }
-    forEach(func) {
-        forEach(this.source, func);
-    }
-    forceCast() {
-        return this;
-    }
-    group(selector) {
-        const grouped = group(this.source, selector);
-        return new Enumerable(grouped);
-    }
-    groupSingle(selector) {
-        const grouped = groupSingle(this.source, selector);
-        return new Enumerable(grouped);
-    }
-    groupToMap(selector) {
-        return groupToMap(this.source, selector);
-    }
-    groupToSingleMap(selector) {
-        return groupToSingleMap(this.source, selector);
-    }
-    tap(tapper) {
-        const iterator = tap(this.source, tapper);
-        return new Enumerable(iterator);
-    }
-    last(predicate) {
-        return last(this.source, predicate);
-    }
-    lastOrDefault(defaultValue, predicate) {
-        return lastOrDefault(this.source, defaultValue, predicate);
-    }
-    map(mapper) {
-        const mapped = map(this.source, mapper);
-        return new Enumerable(mapped);
-    }
-    mapMany(mapper) {
-        const result = mapMany(this.source, mapper);
-        return new Enumerable(result);
-    }
-    materialize() {
-        const materialized = materialize(this.source);
-        return new Enumerable(materialized);
-    }
-    metadata() {
-        const metadated = metadata(this.source);
-        return new Enumerable(metadated);
-    }
-    pairwise() {
-        const pairwised = pairwise(this.source);
-        return new Enumerable(pairwised);
-    }
-    reduce(reducer, initialValue) {
-        return reduce(this.source, reducer, initialValue);
-    }
-    single(predicate) {
-        return single(this.source, predicate);
-    }
-    singleOrDefault(defaultValue, predicate) {
-        return singleOrDefault(this.source, defaultValue, predicate);
-    }
-    skip(count) {
-        const skipped = skip(this.source, count);
-        return new Enumerable(skipped);
-    }
-    sort(comparator) {
-        return Enumerable.fromDeferred(() => sort(this.source, comparator));
-    }
-    sortToArray(comparator) {
-        return sort(this.source, comparator);
-    }
-    take(count) {
-        const taken = take(this.source, count);
-        return new Enumerable(taken);
-    }
-    takeUntil(cancellationToken) {
-        const taken = takeUntil(this.source, cancellationToken);
-        return new Enumerable(taken);
-    }
-    takeWhile(yieldLastOnFalse, predicate) {
-        const taken = takeWhile(this.source, yieldLastOnFalse, predicate);
-        return new Enumerable(taken);
-    }
-    toArray() {
-        return [...this.source];
-    }
-    toAsync() {
-        return AsyncEnumerable.from(this.source);
-    }
-    toIterator() {
-        return this.source[Symbol.iterator]();
-    }
-    toSet() {
-        return new Set(this);
-    }
-    toSync() {
-        return this;
-    }
-    while(predicate) {
-        return whileSync(this.source, predicate);
-    }
-    *[Symbol.iterator]() {
-        yield* this.source;
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all2) => {
+  for (var name in all2)
+    __defProp(target, name, { get: all2[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 enumerable_exports = {};
+__export(enumerable_exports, {
+  Enumerable: () => Enumerable
+});
+module.exports = __toCommonJS(enumerable_exports);
+var import_iterable_helpers = require("../utils/iterable-helpers/index.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_async_enumerable = require("./async-enumerable.js");
+class Enumerable {
+  source;
+  constructor(iterable) {
+    this.source = iterable;
+  }
+  static from(source) {
+    return new Enumerable(source);
+  }
+  static fromDeferred(source) {
+    const deferred = (0, import_iterable_helpers.deferredIterable)(source);
+    return new Enumerable(deferred);
+  }
+  static fromRange(fromInclusive, toInclusive) {
+    const rangeIterable = (0, import_iterable_helpers.range)(fromInclusive, toInclusive);
+    return new Enumerable(rangeIterable);
+  }
+  assert(predicate) {
+    const asserted = (0, import_iterable_helpers.assert)(this.source, predicate);
+    return new Enumerable(asserted);
+  }
+  all(predicate) {
+    return (0, import_iterable_helpers.all)(this.source, predicate);
+  }
+  any(predicate) {
+    return (0, import_iterable_helpers.any)(this.source, predicate);
+  }
+  batch(size) {
+    const batched = (0, import_iterable_helpers.batch)(this.source, size);
+    return new Enumerable(batched);
+  }
+  cast() {
+    return this;
+  }
+  concat(...iterables) {
+    const concatted = (0, import_iterable_helpers.concat)(this.source, ...iterables);
+    return new Enumerable(concatted);
+  }
+  defaultIfEmpty(defaultValue) {
+    const result = (0, import_iterable_helpers.defaultIfEmpty)(this.source, defaultValue);
+    return new Enumerable(result);
+  }
+  difference(iterable, selector) {
+    const result = (0, import_iterable_helpers.difference)(this.source, iterable, selector);
+    return new Enumerable(result);
+  }
+  differenceMany(iterables, selector) {
+    const result = (0, import_iterable_helpers.differenceMany)(this.source, iterables, selector);
+    return new Enumerable(result);
+  }
+  distinct(selector) {
+    const result = (0, import_iterable_helpers.distinct)(this.source, selector);
+    return new Enumerable(result);
+  }
+  includes(value) {
+    return (0, import_iterable_helpers.includes)(this.source, value);
+  }
+  drain() {
+    (0, import_iterable_helpers.drain)(this.source);
+  }
+  filter(predicate) {
+    const filtered = (0, import_iterable_helpers.filter)(this.source, predicate);
+    return new Enumerable(filtered);
+  }
+  filterNullOrUndefined() {
+    return this.filter((item) => (0, import_type_guards.isNotNullOrUndefined)(item));
+  }
+  first(predicate) {
+    return (0, import_iterable_helpers.first)(this.source, predicate);
+  }
+  firstOrDefault(defaultValue, predicate) {
+    return (0, import_iterable_helpers.firstOrDefault)(this.source, defaultValue, predicate);
+  }
+  forEach(func) {
+    (0, import_iterable_helpers.forEach)(this.source, func);
+  }
+  forceCast() {
+    return this;
+  }
+  group(selector) {
+    const grouped = (0, import_iterable_helpers.group)(this.source, selector);
+    return new Enumerable(grouped);
+  }
+  groupSingle(selector) {
+    const grouped = (0, import_iterable_helpers.groupSingle)(this.source, selector);
+    return new Enumerable(grouped);
+  }
+  groupToMap(selector) {
+    return (0, import_iterable_helpers.groupToMap)(this.source, selector);
+  }
+  groupToSingleMap(selector) {
+    return (0, import_iterable_helpers.groupToSingleMap)(this.source, selector);
+  }
+  tap(tapper) {
+    const iterator = (0, import_iterable_helpers.tap)(this.source, tapper);
+    return new Enumerable(iterator);
+  }
+  last(predicate) {
+    return (0, import_iterable_helpers.last)(this.source, predicate);
+  }
+  lastOrDefault(defaultValue, predicate) {
+    return (0, import_iterable_helpers.lastOrDefault)(this.source, defaultValue, predicate);
+  }
+  map(mapper) {
+    const mapped = (0, import_iterable_helpers.map)(this.source, mapper);
+    return new Enumerable(mapped);
+  }
+  mapMany(mapper) {
+    const result = (0, import_iterable_helpers.mapMany)(this.source, mapper);
+    return new Enumerable(result);
+  }
+  materialize() {
+    const materialized = (0, import_iterable_helpers.materialize)(this.source);
+    return new Enumerable(materialized);
+  }
+  metadata() {
+    const metadated = (0, import_iterable_helpers.metadata)(this.source);
+    return new Enumerable(metadated);
+  }
+  pairwise() {
+    const pairwised = (0, import_iterable_helpers.pairwise)(this.source);
+    return new Enumerable(pairwised);
+  }
+  reduce(reducer, initialValue) {
+    return (0, import_iterable_helpers.reduce)(this.source, reducer, initialValue);
+  }
+  single(predicate) {
+    return (0, import_iterable_helpers.single)(this.source, predicate);
+  }
+  singleOrDefault(defaultValue, predicate) {
+    return (0, import_iterable_helpers.singleOrDefault)(this.source, defaultValue, predicate);
+  }
+  skip(count) {
+    const skipped = (0, import_iterable_helpers.skip)(this.source, count);
+    return new Enumerable(skipped);
+  }
+  sort(comparator) {
+    return Enumerable.fromDeferred(() => (0, import_iterable_helpers.sort)(this.source, comparator));
+  }
+  sortToArray(comparator) {
+    return (0, import_iterable_helpers.sort)(this.source, comparator);
+  }
+  take(count) {
+    const taken = (0, import_iterable_helpers.take)(this.source, count);
+    return new Enumerable(taken);
+  }
+  takeUntil(cancellationToken) {
+    const taken = (0, import_iterable_helpers.takeUntil)(this.source, cancellationToken);
+    return new Enumerable(taken);
+  }
+  takeWhile(yieldLastOnFalse, predicate) {
+    const taken = (0, import_iterable_helpers.takeWhile)(this.source, yieldLastOnFalse, predicate);
+    return new Enumerable(taken);
+  }
+  toArray() {
+    return [...this.source];
+  }
+  toAsync() {
+    return import_async_enumerable.AsyncEnumerable.from(this.source);
+  }
+  toIterator() {
+    return this.source[Symbol.iterator]();
+  }
+  toSet() {
+    return new Set(this);
+  }
+  toSync() {
+    return this;
+  }
+  while(predicate) {
+    return (0, import_iterable_helpers.whileSync)(this.source, predicate);
+  }
+  *[Symbol.iterator]() {
+    yield* this.source;
+  }
 }
-//# sourceMappingURL=enumerable.js.map

package/enumerable/index.js

@@ -1,3 +1,19 @@
-export * from './async-enumerable.js';
-export * from './enumerable.js';
-//# sourceMappingURL=index.js.map
+"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 enumerable_exports = {};
+module.exports = __toCommonJS(enumerable_exports);
+__reExport(enumerable_exports, require("./async-enumerable.js"), module.exports);
+__reExport(enumerable_exports, require("./enumerable.js"), module.exports);

package/environment.d.ts

@@ -1,3 +1,5 @@
+export declare const isCjs: boolean;
+export declare const isEsm: boolean;
 export declare const isBrowserWindow: boolean;
 export declare const isDedicatedWorker: boolean;
 export declare const isSharedWorker: boolean;
@@ -5,8 +7,7 @@ export declare const isServiceWorker: boolean;
 export declare const isBrowserWorker: boolean;
 export declare const isBrowser: boolean;
 export declare const isNode: boolean;
-export declare const isNodeWorker: boolean;
+export declare const isNodeWorker: () => Promise<boolean>;
 export declare const isDeno: boolean;
-export declare const isWorker: boolean;
-declare const hardwareConcurrency: number | undefined;
-export { hardwareConcurrency };
+export declare const isWorker: () => Promise<boolean>;
+export declare const hardwareConcurrency: number | undefined;

package/environment.js

@@ -1,28 +1,61 @@
-import { dynamicImport } from './import.js';
-export const isBrowserWindow = (typeof window != 'undefined') && (typeof window.document != 'undefined');
-export const isDedicatedWorker = checkIfIsWorker('DedicatedWorkerGlobalScope');
-export const isSharedWorker = checkIfIsWorker('SharedWorkerGlobalScope');
-export const isServiceWorker = checkIfIsWorker('ServiceWorkerGlobalScope');
-export const isBrowserWorker = isDedicatedWorker || isSharedWorker || isServiceWorker;
-export const isBrowser = isBrowserWindow || isBrowserWorker;
-export const isNode = (typeof process == 'object') && (typeof process.versions?.node == 'string');
-export const isNodeWorker = isNode && (await checkIfIsNodeWorkerThread());
-export const isDeno = (typeof Deno == 'object') && (typeof Deno.version?.deno == 'string');
-export const isWorker = isBrowserWorker || isNodeWorker;
-const hardwareConcurrency = isNode
-    ? (await dynamicImport('os')).cpus().length
-    : globalThis.navigator?.hardwareConcurrency;
+"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 environment_exports = {};
+__export(environment_exports, {
+  hardwareConcurrency: () => hardwareConcurrency,
+  isBrowser: () => isBrowser,
+  isBrowserWindow: () => isBrowserWindow,
+  isBrowserWorker: () => isBrowserWorker,
+  isCjs: () => isCjs,
+  isDedicatedWorker: () => isDedicatedWorker,
+  isDeno: () => isDeno,
+  isEsm: () => isEsm,
+  isNode: () => isNode,
+  isNodeWorker: () => isNodeWorker,
+  isServiceWorker: () => isServiceWorker,
+  isSharedWorker: () => isSharedWorker,
+  isWorker: () => isWorker
+});
+module.exports = __toCommonJS(environment_exports);
+var import_import = require("./import.js");
+var import_require = require("./require.js");
+const isCjs = typeof require == "function" && typeof module == "object";
+const isEsm = !isCjs;
+const isBrowserWindow = typeof window != "undefined" && typeof window.document != "undefined";
+const isDedicatedWorker = checkIfIsWorker("DedicatedWorkerGlobalScope");
+const isSharedWorker = checkIfIsWorker("SharedWorkerGlobalScope");
+const isServiceWorker = checkIfIsWorker("ServiceWorkerGlobalScope");
+const isBrowserWorker = isDedicatedWorker || isSharedWorker || isServiceWorker;
+const isBrowser = isBrowserWindow || isBrowserWorker;
+const isNode = typeof process == "object" && typeof process.versions?.node == "string";
+const isNodeWorker = async () => isNode && await checkIfIsNodeWorkerThread();
+const isDeno = typeof Deno == "object" && typeof Deno.version?.deno == "string";
+const isWorker = async () => isBrowserWorker || await isNodeWorker();
+const hardwareConcurrency = isNode ? isCjs ? (0, import_require.dynamicRequire)("os").cpus().length : void 0 : globalThis.navigator?.hardwareConcurrency;
 function checkIfIsWorker(constructorName) {
-    return (typeof globalThis == 'object') && globalThis.constructor.name == constructorName;
+  return typeof globalThis == "object" && globalThis.constructor.name == constructorName;
 }
 async function checkIfIsNodeWorkerThread() {
-    try {
-        const nodeWorkerThreads = await dynamicImport('nodeworker_threads');
-        return !nodeWorkerThreads.isMainThread;
-    }
-    catch {
-        return false;
-    }
+  try {
+    const nodeWorkerThreads = await (0, import_import.dynamicImport)("nodeworker_threads");
+    return !nodeWorkerThreads.isMainThread;
+  } catch {
+    return false;
+  }
 }
-export { hardwareConcurrency };
-//# sourceMappingURL=environment.js.map

package/error/api.error.js

@@ -1,13 +1,34 @@
-import { CustomError } from './custom.error.js';
-class ApiError extends CustomError {
-    static errorName = 'ApiError';
-    details;
-    response;
-    constructor(response) {
-        super({ name: 'ApiError', message: `${response.error.name} - ${response.error.message}` });
-        this.response = response;
-        this.details = response.error.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 api_error_exports = {};
+__export(api_error_exports, {
+  ApiError: () => ApiError
+});
+module.exports = __toCommonJS(api_error_exports);
+var import_custom_error = require("./custom.error.js");
+class ApiError extends import_custom_error.CustomError {
+  static errorName = "ApiError";
+  details;
+  response;
+  constructor(response) {
+    super({ name: "ApiError", message: `${response.error.name} - ${response.error.message}` });
+    this.response = response;
+    this.details = response.error.details;
+  }
 }
-export { ApiError };
-//# sourceMappingURL=api.error.js.map

package/error/assertion.error.js

@@ -1,9 +1,30 @@
-import { CustomError } from './custom.error.js';
-class AssertionError extends CustomError {
-    static errorName = 'AssertionError';
-    constructor(message) {
-        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 assertion_error_exports = {};
+__export(assertion_error_exports, {
+  AssertionError: () => AssertionError
+});
+module.exports = __toCommonJS(assertion_error_exports);
+var import_custom_error = require("./custom.error.js");
+class AssertionError extends import_custom_error.CustomError {
+  static errorName = "AssertionError";
+  constructor(message) {
+    super({ message });
+  }
 }
-export { AssertionError };
-//# sourceMappingURL=assertion.error.js.map

package/error/bad-request.error.js

@@ -1,9 +1,30 @@
-import { CustomError } from './custom.error.js';
-class BadRequestError extends CustomError {
-    static errorName = 'BadRequestError';
-    constructor(message = 'bad request') {
-        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 bad_request_error_exports = {};
+__export(bad_request_error_exports, {
+  BadRequestError: () => BadRequestError
+});
+module.exports = __toCommonJS(bad_request_error_exports);
+var import_custom_error = require("./custom.error.js");
+class BadRequestError extends import_custom_error.CustomError {
+  static errorName = "BadRequestError";
+  constructor(message = "bad request") {
+    super({ message });
+  }
 }
-export { BadRequestError };
-//# sourceMappingURL=bad-request.error.js.map