@naturalcycles/js-lib 14.276.0 → 15.0.0

package/dist/enum.util.js

@@ -1,47 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._numberEnumKeys = _numberEnumKeys;
-exports._numberEnumValues = _numberEnumValues;
-exports._stringEnumKeys = _stringEnumKeys;
-exports._stringEnumValues = _stringEnumValues;
-exports._numberEnumEntries = _numberEnumEntries;
-exports._numberEnumEntriesReversed = _numberEnumEntriesReversed;
-exports._numberEnumAsMap = _numberEnumAsMap;
-exports._numberEnumAsMapReversed = _numberEnumAsMapReversed;
-exports._stringEnumEntries = _stringEnumEntries;
-exports._stringEnumEntriesReversed = _stringEnumEntriesReversed;
-exports._stringEnumAsMap = _stringEnumAsMap;
-exports._stringEnumAsMapReversed = _stringEnumAsMapReversed;
-exports._numberEnumValue = _numberEnumValue;
-exports._numberEnumValueOrUndefined = _numberEnumValueOrUndefined;
-exports._numberEnumNormalize = _numberEnumNormalize;
-exports._numberEnumNormalizeOrUndefined = _numberEnumNormalizeOrUndefined;
-exports._numberEnumKeyOrUndefined = _numberEnumKeyOrUndefined;
-exports._numberEnumKey = _numberEnumKey;
-exports._stringEnumKeyOrUndefined = _stringEnumKeyOrUndefined;
-exports._stringEnumKey = _stringEnumKey;
 /**
  * Returns all String keys of a number-enum.
  */
-function _numberEnumKeys(en) {
+export function _numberEnumKeys(en) {
     return Object.values(en).filter(k => typeof k === 'string');
 }
 /**
  * Returns all Number values of a number-enum.
  */
-function _numberEnumValues(en) {
+export function _numberEnumValues(en) {
     return Object.values(en).filter(k => typeof k === 'number');
 }
 /**
  * Returns all String keys of a string-enum.
  */
-function _stringEnumKeys(en) {
+export function _stringEnumKeys(en) {
     return Object.keys(en);
 }
 /**
  * Returns all String values of a string-enum.
  */
-function _stringEnumValues(en) {
+export function _stringEnumValues(en) {
     // filtering here is unnecessary, but works as a safety in case Number-enum is passed
     return Object.values(en).filter(k => typeof k === 'string');
 }
@@ -51,7 +29,7 @@ function _stringEnumValues(en) {
  *
  * Doesn't work on String-enums!
  */
-function _numberEnumEntries(en) {
+export function _numberEnumEntries(en) {
     return Object.values(en)
         .filter(k => typeof k === 'string')
         .map(k => [k, en[k]]);
@@ -60,7 +38,7 @@ function _numberEnumEntries(en) {
  * Like _numberEnumEntries, but reversed.
  * So, keys are Numbers, values are Strings.
  */
-function _numberEnumEntriesReversed(en) {
+export function _numberEnumEntriesReversed(en) {
     return Object.values(en)
         .filter(k => typeof k === 'string')
         .map(k => [en[k], k]);
@@ -69,7 +47,7 @@ function _numberEnumEntriesReversed(en) {
  * Like _numberEnumEntries, but as a Map.
  * Keys are Strings, values are Numbers.
  */
-function _numberEnumAsMap(en) {
+export function _numberEnumAsMap(en) {
     return new Map(Object.values(en)
         .filter(k => typeof k === 'string')
         .map(k => [k, en[k]]));
@@ -78,7 +56,7 @@ function _numberEnumAsMap(en) {
  * Like _numberEnumEntriesReversed, but as a Map.
  * Keys are Numbers (actual Numbers, because it's a Map, not an Object), values are Strings.
  */
-function _numberEnumAsMapReversed(en) {
+export function _numberEnumAsMapReversed(en) {
     return new Map(Object.values(en)
         .filter(k => typeof k === 'string')
         .map(k => [en[k], k]));
@@ -89,25 +67,25 @@ function _numberEnumAsMapReversed(en) {
  *
  * Doesn't work on Number-enums!
  */
-function _stringEnumEntries(en) {
+export function _stringEnumEntries(en) {
     return Object.entries(en);
 }
 /**
  * Like _stringEnumEntries, but keys and values are reversed.
  */
-function _stringEnumEntriesReversed(en) {
+export function _stringEnumEntriesReversed(en) {
     return Object.entries(en).map(([k, v]) => [v, k]);
 }
 /**
  * Return String enum as Map (with the same keys and values).
  */
-function _stringEnumAsMap(en) {
+export function _stringEnumAsMap(en) {
     return new Map(Object.entries(en));
 }
 /**
  * Return String enum as Map, with keys and values reversed.
  */
-function _stringEnumAsMapReversed(en) {
+export function _stringEnumAsMapReversed(en) {
     return new Map(Object.entries(en).map(([k, v]) => [v, k]));
 }
 /**
@@ -118,7 +96,7 @@ function _stringEnumAsMapReversed(en) {
  *
  * Throws if value is not found!
  */
-function _numberEnumValue(en, k) {
+export function _numberEnumValue(en, k) {
     const r = en[k];
     if (!r)
         throw new Error(`_numberEnumValue not found for: ${k}`);
@@ -127,7 +105,7 @@ function _numberEnumValue(en, k) {
 /**
  * _numberEnumKey, but allows to get/return undefined output.
  */
-function _numberEnumValueOrUndefined(en, k) {
+export function _numberEnumValueOrUndefined(en, k) {
     return en[k];
 }
 /**
@@ -136,7 +114,7 @@ function _numberEnumValueOrUndefined(en, k) {
  *
  * Throws if value is not found!
  */
-function _numberEnumNormalize(en, v) {
+export function _numberEnumNormalize(en, v) {
     const r = _numberEnumNormalizeOrUndefined(en, v);
     if (!r || !en[r])
         throw new Error(`_numberEnumNormalize value not found for: ${v}`);
@@ -145,13 +123,13 @@ function _numberEnumNormalize(en, v) {
 /**
  * Same as _numberEnumNormalize, but allows to return undefined values.
  */
-function _numberEnumNormalizeOrUndefined(en, v) {
+export function _numberEnumNormalizeOrUndefined(en, v) {
     return typeof v === 'string' ? en[v] : v;
 }
 /**
  * Returns a String key for given NumberEnum value, or undefined if not found.
  */
-function _numberEnumKeyOrUndefined(en, v) {
+export function _numberEnumKeyOrUndefined(en, v) {
     const key = en[v];
     // This prevents passing a Key (not a Value) of enum here, which returns unexpected result (number, not string)
     return typeof key === 'string' ? key : undefined;
@@ -159,19 +137,19 @@ function _numberEnumKeyOrUndefined(en, v) {
 /**
  * Returns a String key for given NumberEnum value, throws if not found.
  */
-function _numberEnumKey(en, v) {
+export function _numberEnumKey(en, v) {
     const key = en[v];
     // This prevents passing a Key (not a Value) of enum here, which returns unexpected result (number, not string)
     if (typeof key !== 'string')
         throw new Error(`_numberEnumKey not found for: ${v}`);
     return key;
 }
-function _stringEnumKeyOrUndefined(en, 
+export function _stringEnumKeyOrUndefined(en, 
 // v: T[keyof T] | undefined | null, // cannot make it type-safe :(
 v) {
     return Object.entries(en).find(([_, v2]) => v2 === v)?.[0];
 }
-function _stringEnumKey(en, v) {
+export function _stringEnumKey(en, v) {
     const r = _stringEnumKeyOrUndefined(en, v);
     if (!r)
         throw new Error(`_stringEnumKey not found for: ${v}`);

package/dist/env/buildInfo.d.ts

@@ -1,4 +1,4 @@
-import type { UnixTimestamp } from '../types';
+import type { UnixTimestamp } from '../types.js';
 export interface BuildInfo {
     /**
      * Unix timestamp of when the build was made.

package/dist/env/buildInfo.js

@@ -1,9 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateBuildInfoDev = generateBuildInfoDev;
-const localTime_1 = require("../datetime/localTime");
-function generateBuildInfoDev() {
-    const now = localTime_1.localTime.now();
+import { localTime } from '../datetime/localTime.js';
+export function generateBuildInfoDev() {
+    const now = localTime.now();
     const ts = now.unix;
     const rev = 'devRev';
     const branchName = 'devBranch';

package/dist/env.js

@@ -1,14 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isServerSide = isServerSide;
-exports.isClientSide = isClientSide;
 /**
  * Use it to detect SSR/Node.js environment.
  *
  * Will return `true` in Node.js.
  * Will return `false` in the Browser.
  */
-function isServerSide() {
+export function isServerSide() {
     return !isClientSide();
 }
 /**
@@ -17,7 +13,7 @@ function isServerSide() {
  * Will return `true` in the Browser.
  * Will return `false` in Node.js.
  */
-function isClientSide() {
+export function isClientSide() {
     // eslint-disable-next-line unicorn/prefer-global-this
     return typeof window !== 'undefined' && !!window?.document;
 }

package/dist/error/assert.d.ts

@@ -1,6 +1,6 @@
-import type { Class } from '../typeFest';
-import type { UnixTimestamp } from '../types';
-import type { BackendErrorResponseObject, ErrorData, ErrorObject } from './error.model';
+import type { Class } from '../typeFest.js';
+import type { UnixTimestamp } from '../types.js';
+import type { BackendErrorResponseObject, ErrorData, ErrorObject } from './error.model.js';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.

package/dist/error/assert.js

@@ -1,21 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._assert = _assert;
-exports._assertEquals = _assertEquals;
-exports._assertDeepEquals = _assertDeepEquals;
-exports._assertIsError = _assertIsError;
-exports._assertErrorClassOrRethrow = _assertErrorClassOrRethrow;
-exports._assertIsErrorObject = _assertIsErrorObject;
-exports._assertIsBackendErrorResponseObject = _assertIsBackendErrorResponseObject;
-exports._assertIsString = _assertIsString;
-exports._assertIsNumber = _assertIsNumber;
-exports._assertTypeOf = _assertTypeOf;
-exports.asUnixTimestamp = asUnixTimestamp;
-exports.asUnixTimestamp2000 = asUnixTimestamp2000;
-const deepEquals_1 = require("../object/deepEquals");
-const stringify_1 = require("../string/stringify");
-const zod_shared_schemas_1 = require("../zod/zod.shared.schemas");
-const error_util_1 = require("./error.util");
+import { _deepEquals } from '../object/deepEquals.js';
+import { _stringify } from '../string/stringify.js';
+import { TS_2000, TS_2500 } from '../zod/zod.shared.schemas.js';
+import { _isBackendErrorResponseObject, _isErrorObject, AssertionError } from './error.util.js';
 /**
  * Evaluates the `condition` (casts it to Boolean).
  * Expects it to be truthy, otherwise throws AppError.
@@ -32,10 +18,10 @@ const error_util_1 = require("./error.util");
  *
  * Since 2024-07-10 it no longer sets `userFriendly: true` by default.
  */
-function _assert(condition, // will be evaluated as Boolean
+export function _assert(condition, // will be evaluated as Boolean
 message, errorData) {
     if (!condition) {
-        throw new error_util_1.AssertionError(message || 'condition failed', {
+        throw new AssertionError(message || 'condition failed', {
             ...errorData,
         });
     }
@@ -46,13 +32,13 @@ message, errorData) {
  *
  * Does SHALLOW, but strict equality (===), use _assertDeepEquals() for deep equality.
  */
-function _assertEquals(actual, expected, message, errorData) {
+export function _assertEquals(actual, expected, message, errorData) {
     if (actual !== expected) {
         const msg = message ||
-            ['not equal', `expected: ${(0, stringify_1._stringify)(expected)}`, `got     : ${(0, stringify_1._stringify)(actual)}`]
+            ['not equal', `expected: ${_stringify(expected)}`, `got     : ${_stringify(actual)}`]
                 .filter(Boolean)
                 .join('\n');
-        throw new error_util_1.AssertionError(msg, {
+        throw new AssertionError(msg, {
             ...errorData,
         });
     }
@@ -63,20 +49,20 @@ function _assertEquals(actual, expected, message, errorData) {
  *
  * Does DEEP equality via _deepEquals()
  */
-function _assertDeepEquals(actual, expected, message, errorData) {
-    if (!(0, deepEquals_1._deepEquals)(actual, expected)) {
+export function _assertDeepEquals(actual, expected, message, errorData) {
+    if (!_deepEquals(actual, expected)) {
         const msg = message ||
-            ['not deeply equal', `expected: ${(0, stringify_1._stringify)(expected)}`, `got     : ${(0, stringify_1._stringify)(actual)}`]
+            ['not deeply equal', `expected: ${_stringify(expected)}`, `got     : ${_stringify(actual)}`]
                 .filter(Boolean)
                 .join('\n');
-        throw new error_util_1.AssertionError(msg, {
+        throw new AssertionError(msg, {
             ...errorData,
         });
     }
 }
-function _assertIsError(err, errorClass = Error) {
+export function _assertIsError(err, errorClass = Error) {
     if (!(err instanceof errorClass)) {
-        throw new error_util_1.AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
+        throw new AssertionError(`Expected to be instanceof ${errorClass.name}, actual typeof: ${typeof err}`);
     }
 }
 /**
@@ -84,33 +70,33 @@ function _assertIsError(err, errorClass = Error) {
  * If yes - returns peacefully (with TypeScript assertion).
  * In not - throws (re-throws) that error up.
  */
-function _assertErrorClassOrRethrow(err, errorClass) {
+export function _assertErrorClassOrRethrow(err, errorClass) {
     if (!(err instanceof errorClass)) {
         // re-throw
         throw err;
     }
 }
-function _assertIsErrorObject(obj) {
-    if (!(0, error_util_1._isErrorObject)(obj)) {
-        throw new error_util_1.AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
+export function _assertIsErrorObject(obj) {
+    if (!_isErrorObject(obj)) {
+        throw new AssertionError(`Expected to be ErrorObject, actual typeof: ${typeof obj}`);
     }
 }
-function _assertIsBackendErrorResponseObject(obj) {
-    if (!(0, error_util_1._isBackendErrorResponseObject)(obj)) {
-        throw new error_util_1.AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
+export function _assertIsBackendErrorResponseObject(obj) {
+    if (!_isBackendErrorResponseObject(obj)) {
+        throw new AssertionError(`Expected to be BackendErrorResponseObject, actual typeof: ${typeof obj}`);
     }
 }
-function _assertIsString(v, message) {
+export function _assertIsString(v, message) {
     _assertTypeOf(v, 'string', message);
 }
-function _assertIsNumber(v, message) {
+export function _assertIsNumber(v, message) {
     _assertTypeOf(v, 'number', message);
 }
-function _assertTypeOf(v, expectedType, message) {
+export function _assertTypeOf(v, expectedType, message) {
     // biome-ignore lint/suspicious/useValidTypeof: ok
     if (typeof v !== expectedType) {
         const msg = message || `Expected typeof ${expectedType}, actual typeof: ${typeof v}`;
-        throw new error_util_1.AssertionError(msg);
+        throw new AssertionError(msg);
     }
 }
 /**
@@ -118,7 +104,7 @@ function _assertTypeOf(v, expectedType, message) {
  * Right now does not perform any validation (unlike `asUnixTimestamp2000`),
  * but only type casting.
  */
-function asUnixTimestamp(n) {
+export function asUnixTimestamp(n) {
     return n;
 }
 /**
@@ -126,9 +112,9 @@ function asUnixTimestamp(n) {
  * Throws if the number is not inside 2000-01-01 and 2500-01-01 time interval,
  * which would indicate a bug.
  */
-function asUnixTimestamp2000(n) {
-    if (!n || n < zod_shared_schemas_1.TS_2000 || n > zod_shared_schemas_1.TS_2500) {
-        throw new error_util_1.AssertionError(`Number is not a valid UnixTimestamp2000: ${n}`, {
+export function asUnixTimestamp2000(n) {
+    if (!n || n < TS_2000 || n > TS_2500) {
+        throw new AssertionError(`Number is not a valid UnixTimestamp2000: ${n}`, {
             fingerprint: 'asUnixTimestamp2000',
         });
     }

package/dist/error/error.model.d.ts

@@ -1,5 +1,5 @@
-import type { HttpMethod, HttpStatusCode } from '../http/http.model';
-import type { NumberOfMilliseconds } from '../types';
+import type { HttpMethod, HttpStatusCode } from '../http/http.model.js';
+import type { NumberOfMilliseconds } from '../types.js';
 /**
  * Extendable payload object to transfer custom additional data with AppError.
  */

package/dist/error/error.model.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/error/error.util.d.ts

@@ -1,4 +1,4 @@
-import type { BackendErrorResponseObject, Class, ErrorData, ErrorLike, ErrorObject, HttpRequestErrorData } from '..';
+import type { BackendErrorResponseObject, Class, ErrorData, ErrorLike, ErrorObject, HttpRequestErrorData } from '../index.js';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).

package/dist/error/error.util.js

@@ -1,20 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnexpectedPassError = exports.TimeoutError = exports.JsonParseError = exports.AssertionError = exports.HttpRequestError = exports.AppError = void 0;
-exports._anyToError = _anyToError;
-exports._anyToErrorObject = _anyToErrorObject;
-exports._errorLikeToErrorObject = _errorLikeToErrorObject;
-exports._errorObjectToError = _errorObjectToError;
-exports._errorSnippet = _errorSnippet;
-exports._isBackendErrorResponseObject = _isBackendErrorResponseObject;
-exports._isHttpRequestErrorObject = _isHttpRequestErrorObject;
-exports._isErrorObject = _isErrorObject;
-exports._isErrorLike = _isErrorLike;
-exports._errorDataAppend = _errorDataAppend;
-const env_1 = require("../env");
-const json_util_1 = require("../string/json.util");
-const string_util_1 = require("../string/string.util");
-const stringify_1 = require("../string/stringify");
+import { isServerSide } from '../env.js';
+import { _jsonParseIfPossible } from '../string/json.util.js';
+import { _truncate, _truncateMiddle } from '../string/string.util.js';
+import { _stringify } from '../string/stringify.js';
 /**
  * Useful to ensure that error in `catch (err) { ... }`
  * is indeed an Error (and not e.g `string` or `undefined`).
@@ -23,7 +10,7 @@ const stringify_1 = require("../string/stringify");
  *
  * Alternatively, if you're sure it's Error - you can use `_assertIsError(err)`.
  */
-function _anyToError(o, errorClass = Error, errorData) {
+export function _anyToError(o, errorClass = Error, errorData) {
     let e;
     if (o instanceof errorClass) {
         e = o;
@@ -48,13 +35,13 @@ function _anyToError(o, errorClass = Error, errorData) {
  * If object is Error - Error.message will be used.
  * Objects (not Errors) get converted to prettified JSON string (via `_stringify`).
  */
-function _anyToErrorObject(o, errorData) {
+export function _anyToErrorObject(o, errorData) {
     let eo;
     if (_isErrorLike(o)) {
         eo = _errorLikeToErrorObject(o);
     }
     else {
-        o = (0, json_util_1._jsonParseIfPossible)(o);
+        o = _jsonParseIfPossible(o);
         if (_isBackendErrorResponseObject(o)) {
             eo = o.error;
         }
@@ -69,7 +56,7 @@ function _anyToErrorObject(o, errorData) {
             // so, fair to return `data: {}` in the end
             // Also we're sure it includes no "error name", e.g no `Error: ...`,
             // so, fair to include `name: 'Error'`
-            const message = (0, stringify_1._stringify)(o);
+            const message = _stringify(o);
             eo = {
                 name: 'Error',
                 message,
@@ -80,7 +67,7 @@ function _anyToErrorObject(o, errorData) {
     Object.assign(eo.data, errorData);
     return eo;
 }
-function _errorLikeToErrorObject(e) {
+export function _errorLikeToErrorObject(e) {
     // If it's already an ErrorObject - just return it
     // AppError satisfies ErrorObject interface
     // Error does not satisfy (lacks `data`)
@@ -101,7 +88,7 @@ function _errorLikeToErrorObject(e) {
     }
     return obj;
 }
-function _errorObjectToError(o, errorClass = Error) {
+export function _errorObjectToError(o, errorClass = Error) {
     if (o instanceof errorClass)
         return o;
     // Here we pass constructor values assuming it's AppError or sub-class of it
@@ -160,7 +147,7 @@ const commonErrorClasses = new Set([
  *
  * It's not supposed to have full information about the error, just a small extract from it.
  */
-function _errorSnippet(err, opt = {}) {
+export function _errorSnippet(err, opt = {}) {
     const { maxLineLength = 60, maxLines = 3 } = opt;
     const e = _anyToErrorObject(err);
     const lines = [errorObjectToSnippet(e)];
@@ -169,7 +156,7 @@ function _errorSnippet(err, opt = {}) {
         lines.push('Caused by ' + errorObjectToSnippet(cause));
         cause = cause.cause; // insert DiCaprio Inception meme
     }
-    return lines.map(line => (0, string_util_1._truncate)(line, maxLineLength)).join('\n');
+    return lines.map(line => _truncate(line, maxLineLength)).join('\n');
     function errorObjectToSnippet(e) {
         // Return snippet if it was already prepared
         if (e.data.snippet)
@@ -186,23 +173,23 @@ function _errorSnippet(err, opt = {}) {
             .join(': ');
     }
 }
-function _isBackendErrorResponseObject(o) {
+export function _isBackendErrorResponseObject(o) {
     return _isErrorObject(o?.error);
 }
-function _isHttpRequestErrorObject(o) {
+export function _isHttpRequestErrorObject(o) {
     return !!o && o.name === 'HttpRequestError' && typeof o.data?.requestUrl === 'string';
 }
 /**
  * Note: any instance of AppError is also automatically an ErrorObject
  */
-function _isErrorObject(o) {
+export function _isErrorObject(o) {
     return (!!o &&
         typeof o === 'object' &&
         typeof o.name === 'string' &&
         typeof o.message === 'string' &&
         typeof o.data === 'object');
 }
-function _isErrorLike(o) {
+export function _isErrorLike(o) {
     return !!o && typeof o === 'object' && typeof o.name === 'string' && typeof o.message === 'string';
 }
 /**
@@ -219,7 +206,7 @@ function _isErrorLike(o) {
  *   })
  * }
  */
-function _errorDataAppend(err, data) {
+export function _errorDataAppend(err, data) {
     if (!data)
         return err;
     err.data ||= {}; // create err.data if it doesn't exist
@@ -236,7 +223,7 @@ function _errorDataAppend(err, data) {
  *
  * Based on: https://medium.com/@xpl/javascript-deriving-from-error-properly-8d2f8f315801
  */
-class AppError extends Error {
+export class AppError extends Error {
     data;
     /**
      * `cause` here is normalized to be an ErrorObject
@@ -255,7 +242,7 @@ class AppError extends Error {
         super(message);
         // Here we default to `this.constructor.name` on Node, but to 'AppError' on the Frontend
         // because Frontend tends to minify class names, so `constructor.name` is not reliable
-        const { name = (0, env_1.isServerSide)() ? this.constructor.name : 'AppError', cause } = opt;
+        const { name = isServerSide() ? this.constructor.name : 'AppError', cause } = opt;
         Object.defineProperties(this, {
             name: {
                 value: name,
@@ -295,7 +282,6 @@ class AppError extends Error {
         // }
     }
 }
-exports.AppError = AppError;
 /**
  * Error that is thrown when Http Request was made and returned an error.
  * Thrown by, for example, Fetcher.
@@ -313,7 +299,7 @@ exports.AppError = AppError;
  * E.g 3rd-party call may return 401, but our Backend will still wrap it into an 500 error
  * (by default).
  */
-class HttpRequestError extends AppError {
+export class HttpRequestError extends AppError {
     constructor(message, data, opt) {
         if (data.response) {
             Object.defineProperty(data, 'response', {
@@ -323,38 +309,33 @@ class HttpRequestError extends AppError {
         super(message, data, { ...opt, name: 'HttpRequestError' });
     }
 }
-exports.HttpRequestError = HttpRequestError;
-class AssertionError extends AppError {
+export class AssertionError extends AppError {
     constructor(message, data) {
         super(message, data, { name: 'AssertionError' });
     }
 }
-exports.AssertionError = AssertionError;
-class JsonParseError extends AppError {
+export class JsonParseError extends AppError {
     constructor(data) {
-        const message = ['Failed to parse', data.text && (0, string_util_1._truncateMiddle)(data.text, 200)]
+        const message = ['Failed to parse', data.text && _truncateMiddle(data.text, 200)]
             .filter(Boolean)
             .join(': ');
         super(message, data, { name: 'JsonParseError' });
     }
 }
-exports.JsonParseError = JsonParseError;
-class TimeoutError extends AppError {
+export class TimeoutError extends AppError {
     constructor(message, data, opt) {
         super(message, data, { ...opt, name: 'TimeoutError' });
     }
 }
-exports.TimeoutError = TimeoutError;
 /**
  * It is thrown when Error was expected, but didn't happen
  * ("pass" happened instead).
  * "Pass" means "no error".
  */
-class UnexpectedPassError extends AppError {
+export class UnexpectedPassError extends AppError {
     constructor(message) {
         super(message || 'expected error was not thrown', {}, {
             name: 'UnexpectedPassError',
         });
     }
 }
-exports.UnexpectedPassError = UnexpectedPassError;

package/dist/error/errorMode.js

@@ -1,12 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ErrorMode = void 0;
 /**
  * Allows to define error-controlling behaviour for batch operations.
  *
  * @default is THROW_IMMEDIATELY in most cases
  */
-var ErrorMode;
+export var ErrorMode;
 (function (ErrorMode) {
     /**
      * Usually a default behaviour, similar as "exit early".
@@ -20,4 +17,4 @@ var ErrorMode;
      * Completely suppress errors, do not aggregate nor throw anything. Resilient mode.
      */
     ErrorMode["SUPPRESS"] = "SUPPRESS";
-})(ErrorMode || (exports.ErrorMode = ErrorMode = {}));
+})(ErrorMode || (ErrorMode = {}));

package/dist/error/try.d.ts

@@ -1,5 +1,5 @@
-import type { Class } from '../typeFest';
-import type { AnyFunction, ErrorDataTuple } from '../types';
+import type { Class } from '../typeFest.js';
+import type { AnyFunction, ErrorDataTuple } from '../types.js';
 /**
  * Calls a function, returns a Tuple of [error, value].
  * Allows to write shorter code that avoids `try/catch`.