@naturalcycles/js-lib 14.42.1 → 14.46.0

package/dist/vendor/is.js

@@ -0,0 +1,466 @@
+"use strict";
+/// <reference lib="es2018"/>
+/// <reference lib="dom"/>
+/// <reference types="node"/>
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = exports.AssertionTypeDescription = exports.is = void 0;
+const typedArrayTypeNames = [
+    'Int8Array',
+    'Uint8Array',
+    'Uint8ClampedArray',
+    'Int16Array',
+    'Uint16Array',
+    'Int32Array',
+    'Uint32Array',
+    'Float32Array',
+    'Float64Array',
+    'BigInt64Array',
+    'BigUint64Array',
+];
+function isTypedArrayName(name) {
+    return typedArrayTypeNames.includes(name);
+}
+const objectTypeNames = [
+    'Function',
+    'Generator',
+    'AsyncGenerator',
+    'GeneratorFunction',
+    'AsyncGeneratorFunction',
+    'AsyncFunction',
+    'Observable',
+    'Array',
+    'Buffer',
+    'Object',
+    'RegExp',
+    'Date',
+    'Error',
+    'Map',
+    'Set',
+    'WeakMap',
+    'WeakSet',
+    'ArrayBuffer',
+    'SharedArrayBuffer',
+    'DataView',
+    'Promise',
+    'URL',
+    'FormData',
+    'URLSearchParams',
+    'HTMLElement',
+    ...typedArrayTypeNames,
+];
+function isObjectTypeName(name) {
+    return objectTypeNames.includes(name);
+}
+const primitiveTypeNames = [
+    'null',
+    'undefined',
+    'string',
+    'number',
+    'bigint',
+    'boolean',
+    'symbol',
+];
+function isPrimitiveTypeName(name) {
+    return primitiveTypeNames.includes(name);
+}
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isOfType(type) {
+    return (value) => typeof value === type;
+}
+const { toString } = Object.prototype;
+const getObjectType = (value) => {
+    const objectTypeName = toString.call(value).slice(8, -1);
+    if (/HTML\w+Element/.test(objectTypeName) && is.domElement(value)) {
+        return 'HTMLElement';
+    }
+    if (isObjectTypeName(objectTypeName)) {
+        return objectTypeName;
+    }
+    return undefined;
+};
+const isObjectOfType = (type) => (value) => getObjectType(value) === type;
+function is(value) {
+    if (value === null) {
+        return 'null';
+    }
+    switch (typeof value) {
+        case 'undefined':
+            return 'undefined';
+        case 'string':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'boolean':
+            return 'boolean';
+        case 'function':
+            return 'Function';
+        case 'bigint':
+            return 'bigint';
+        case 'symbol':
+            return 'symbol';
+        default:
+    }
+    if (is.observable(value)) {
+        return 'Observable';
+    }
+    if (is.array(value)) {
+        return 'Array';
+    }
+    if (is.buffer(value)) {
+        return 'Buffer';
+    }
+    const tagType = getObjectType(value);
+    if (tagType) {
+        return tagType;
+    }
+    if (value instanceof String ||
+        value instanceof Boolean ||
+        value instanceof Number) {
+        throw new TypeError("Please don't use object wrappers for primitive types");
+    }
+    return 'Object';
+}
+exports.is = is;
+is.undefined = isOfType('undefined');
+is.string = isOfType('string');
+const isNumberType = isOfType('number');
+is.number = (value) => isNumberType(value) && !is.nan(value);
+is.bigint = isOfType('bigint');
+// eslint-disable-next-line @typescript-eslint/ban-types
+is.function_ = isOfType('function');
+is.null_ = (value) => value === null;
+is.class_ = (value) => is.function_(value) && value.toString().startsWith('class ');
+is.boolean = (value) => value === true || value === false;
+is.symbol = isOfType('symbol');
+is.numericString = (value) => is.string(value) && !is.emptyStringOrWhitespace(value) && !Number.isNaN(Number(value));
+is.array = (value, assertion) => {
+    if (!Array.isArray(value)) {
+        return false;
+    }
+    if (!is.function_(assertion)) {
+        return true;
+    }
+    return value.every(assertion);
+};
+is.buffer = (value) => value?.constructor?.isBuffer?.(value) ?? false;
+is.nullOrUndefined = (value) => is.null_(value) || is.undefined(value);
+is.object = (value) => !is.null_(value) && (typeof value === 'object' || is.function_(value));
+is.iterable = (value) => is.function_(value?.[Symbol.iterator]);
+is.asyncIterable = (value) => is.function_(value?.[Symbol.asyncIterator]);
+is.generator = (value) => is.iterable(value) && is.function_(value.next) && is.function_(value.throw);
+is.asyncGenerator = (value) => is.asyncIterable(value) && is.function_(value.next) && is.function_(value.throw);
+is.nativePromise = (value) => isObjectOfType('Promise')(value);
+const hasPromiseAPI = (value) => is.function_(value?.then) && is.function_(value?.catch);
+is.promise = (value) => is.nativePromise(value) || hasPromiseAPI(value);
+is.generatorFunction = isObjectOfType('GeneratorFunction');
+is.asyncGeneratorFunction = (value) => getObjectType(value) === 'AsyncGeneratorFunction';
+is.asyncFunction = (value) => getObjectType(value) === 'AsyncFunction';
+// eslint-disable-next-line no-prototype-builtins, @typescript-eslint/ban-types
+is.boundFunction = (value) => is.function_(value) && !value.hasOwnProperty('prototype');
+is.regExp = isObjectOfType('RegExp');
+is.date = isObjectOfType('Date');
+is.error = isObjectOfType('Error');
+is.map = (value) => isObjectOfType('Map')(value);
+is.set = (value) => isObjectOfType('Set')(value);
+is.weakMap = (value) => isObjectOfType('WeakMap')(value);
+is.weakSet = (value) => isObjectOfType('WeakSet')(value);
+is.int8Array = isObjectOfType('Int8Array');
+is.uint8Array = isObjectOfType('Uint8Array');
+is.uint8ClampedArray = isObjectOfType('Uint8ClampedArray');
+is.int16Array = isObjectOfType('Int16Array');
+is.uint16Array = isObjectOfType('Uint16Array');
+is.int32Array = isObjectOfType('Int32Array');
+is.uint32Array = isObjectOfType('Uint32Array');
+is.float32Array = isObjectOfType('Float32Array');
+is.float64Array = isObjectOfType('Float64Array');
+is.bigInt64Array = isObjectOfType('BigInt64Array');
+is.bigUint64Array = isObjectOfType('BigUint64Array');
+is.arrayBuffer = isObjectOfType('ArrayBuffer');
+is.sharedArrayBuffer = isObjectOfType('SharedArrayBuffer');
+is.dataView = isObjectOfType('DataView');
+is.directInstanceOf = (instance, class_) => Object.getPrototypeOf(instance) === class_.prototype;
+is.urlInstance = (value) => isObjectOfType('URL')(value);
+is.urlString = (value) => {
+    if (!is.string(value)) {
+        return false;
+    }
+    try {
+        new URL(value); // eslint-disable-line no-new
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+// TODO: Use the `not` operator with a type guard here when it's available.
+// Example: `is.truthy = (value: unknown): value is (not false | not 0 | not '' | not undefined | not null) => Boolean(value);`
+is.truthy = (value) => Boolean(value);
+// Example: `is.falsy = (value: unknown): value is (not true | 0 | '' | undefined | null) => Boolean(value);`
+is.falsy = (value) => !value;
+is.nan = (value) => Number.isNaN(value);
+is.primitive = (value) => is.null_(value) || isPrimitiveTypeName(typeof value);
+is.integer = (value) => Number.isInteger(value);
+is.safeInteger = (value) => Number.isSafeInteger(value);
+is.plainObject = (value) => {
+    // From: https://github.com/sindresorhus/is-plain-obj/blob/main/index.js
+    if (toString.call(value) !== '[object Object]') {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === null || prototype === Object.getPrototypeOf({});
+};
+is.typedArray = (value) => isTypedArrayName(getObjectType(value));
+const isValidLength = (value) => is.safeInteger(value) && value >= 0;
+is.arrayLike = (value) => !is.nullOrUndefined(value) &&
+    !is.function_(value) &&
+    isValidLength(value.length);
+is.inRange = (value, range) => {
+    if (is.number(range)) {
+        return value >= Math.min(0, range) && value <= Math.max(range, 0);
+    }
+    if (is.array(range) && range.length === 2) {
+        return value >= Math.min(...range) && value <= Math.max(...range);
+    }
+    throw new TypeError(`Invalid range: ${JSON.stringify(range)}`);
+};
+const NODE_TYPE_ELEMENT = 1;
+const DOM_PROPERTIES_TO_CHECK = [
+    'innerHTML',
+    'ownerDocument',
+    'style',
+    'attributes',
+    'nodeValue',
+];
+is.domElement = (value) => {
+    return (is.object(value) &&
+        value.nodeType === NODE_TYPE_ELEMENT &&
+        is.string(value.nodeName) &&
+        !is.plainObject(value) &&
+        DOM_PROPERTIES_TO_CHECK.every(property => property in value));
+};
+is.observable = (value) => {
+    if (!value) {
+        return false;
+    }
+    if (value === value[Symbol.observable]?.()) {
+        return true;
+    }
+    if (value === value['@@observable']?.()) {
+        return true;
+    }
+    return false;
+};
+is.nodeStream = (value) => is.object(value) && is.function_(value.pipe) && !is.observable(value);
+is.infinite = (value) => value === Infinity || value === -Infinity;
+const isAbsoluteMod2 = (remainder) => (value) => is.integer(value) && Math.abs(value % 2) === remainder;
+is.evenInteger = isAbsoluteMod2(0);
+is.oddInteger = isAbsoluteMod2(1);
+is.emptyArray = (value) => is.array(value) && value.length === 0;
+is.nonEmptyArray = (value) => is.array(value) && value.length > 0;
+is.emptyString = (value) => is.string(value) && value.length === 0;
+// TODO: Use `not ''` when the `not` operator is available.
+is.nonEmptyString = (value) => is.string(value) && value.length > 0;
+const isWhiteSpaceString = (value) => is.string(value) && !/\S/.test(value);
+is.emptyStringOrWhitespace = (value) => is.emptyString(value) || isWhiteSpaceString(value);
+is.emptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length === 0;
+// TODO: Use `not` operator here to remove `Map` and `Set` from type guard:
+// - https://github.com/Microsoft/TypeScript/pull/29317
+is.nonEmptyObject = (value) => is.object(value) && !is.map(value) && !is.set(value) && Object.keys(value).length > 0;
+is.emptySet = (value) => is.set(value) && value.size === 0;
+is.nonEmptySet = (value) => is.set(value) && value.size > 0;
+is.emptyMap = (value) => is.map(value) && value.size === 0;
+is.nonEmptyMap = (value) => is.map(value) && value.size > 0;
+// `PropertyKey` is any value that can be used as an object key (string, number, or symbol)
+is.propertyKey = (value) => is.any([is.string, is.number, is.symbol], value);
+is.formData = (value) => isObjectOfType('FormData')(value);
+is.urlSearchParams = (value) => isObjectOfType('URLSearchParams')(value);
+const predicateOnArray = (method, predicate, values) => {
+    if (!is.function_(predicate)) {
+        throw new TypeError(`Invalid predicate: ${JSON.stringify(predicate)}`);
+    }
+    if (values.length === 0) {
+        throw new TypeError('Invalid number of values');
+    }
+    return method.call(values, predicate);
+};
+is.any = (predicate, ...values) => {
+    const predicates = is.array(predicate) ? predicate : [predicate];
+    return predicates.some(singlePredicate => predicateOnArray(Array.prototype.some, singlePredicate, values));
+};
+is.all = (predicate, ...values) => predicateOnArray(Array.prototype.every, predicate, values);
+const assertType = (condition, description, value, options = {}) => {
+    if (!condition) {
+        const { multipleValues } = options;
+        const valuesMessage = multipleValues
+            ? `received values of types ${[
+                ...new Set(value.map(singleValue => `\`${is(singleValue)}\``)),
+            ].join(', ')}`
+            : `received value of type \`${is(value)}\``;
+        throw new TypeError(`Expected value which is \`${description}\`, ${valuesMessage}.`);
+    }
+};
+var AssertionTypeDescription;
+(function (AssertionTypeDescription) {
+    AssertionTypeDescription["class_"] = "Class";
+    AssertionTypeDescription["numericString"] = "string with a number";
+    AssertionTypeDescription["nullOrUndefined"] = "null or undefined";
+    AssertionTypeDescription["iterable"] = "Iterable";
+    AssertionTypeDescription["asyncIterable"] = "AsyncIterable";
+    AssertionTypeDescription["nativePromise"] = "native Promise";
+    AssertionTypeDescription["urlString"] = "string with a URL";
+    AssertionTypeDescription["truthy"] = "truthy";
+    AssertionTypeDescription["falsy"] = "falsy";
+    AssertionTypeDescription["nan"] = "NaN";
+    AssertionTypeDescription["primitive"] = "primitive";
+    AssertionTypeDescription["integer"] = "integer";
+    AssertionTypeDescription["safeInteger"] = "integer";
+    AssertionTypeDescription["plainObject"] = "plain object";
+    AssertionTypeDescription["arrayLike"] = "array-like";
+    AssertionTypeDescription["typedArray"] = "TypedArray";
+    AssertionTypeDescription["domElement"] = "HTMLElement";
+    AssertionTypeDescription["nodeStream"] = "Node.js Stream";
+    AssertionTypeDescription["infinite"] = "infinite number";
+    AssertionTypeDescription["emptyArray"] = "empty array";
+    AssertionTypeDescription["nonEmptyArray"] = "non-empty array";
+    AssertionTypeDescription["emptyString"] = "empty string";
+    AssertionTypeDescription["nonEmptyString"] = "non-empty string";
+    AssertionTypeDescription["emptyStringOrWhitespace"] = "empty string or whitespace";
+    AssertionTypeDescription["emptyObject"] = "empty object";
+    AssertionTypeDescription["nonEmptyObject"] = "non-empty object";
+    AssertionTypeDescription["emptySet"] = "empty set";
+    AssertionTypeDescription["nonEmptySet"] = "non-empty set";
+    AssertionTypeDescription["emptyMap"] = "empty map";
+    AssertionTypeDescription["nonEmptyMap"] = "non-empty map";
+    AssertionTypeDescription["evenInteger"] = "even integer";
+    AssertionTypeDescription["oddInteger"] = "odd integer";
+    AssertionTypeDescription["directInstanceOf"] = "T";
+    AssertionTypeDescription["inRange"] = "in range";
+    AssertionTypeDescription["any"] = "predicate returns truthy for any value";
+    AssertionTypeDescription["all"] = "predicate returns truthy for all values";
+})(AssertionTypeDescription = exports.AssertionTypeDescription || (exports.AssertionTypeDescription = {}));
+exports.assert = {
+    // Unknowns.
+    undefined: (value) => assertType(is.undefined(value), 'undefined', value),
+    string: (value) => assertType(is.string(value), 'string', value),
+    number: (value) => assertType(is.number(value), 'number', value),
+    bigint: (value) => assertType(is.bigint(value), 'bigint', value),
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    function_: (value) => assertType(is.function_(value), 'Function', value),
+    null_: (value) => assertType(is.null_(value), 'null', value),
+    class_: (value) => assertType(is.class_(value), AssertionTypeDescription.class_, value),
+    boolean: (value) => assertType(is.boolean(value), 'boolean', value),
+    symbol: (value) => assertType(is.symbol(value), 'symbol', value),
+    numericString: (value) => assertType(is.numericString(value), AssertionTypeDescription.numericString, value),
+    array: (value, assertion) => {
+        const assert = assertType;
+        assert(is.array(value), 'Array', value);
+        if (assertion) {
+            value.forEach(assertion);
+        }
+    },
+    buffer: (value) => assertType(is.buffer(value), 'Buffer', value),
+    nullOrUndefined: (value) => assertType(is.nullOrUndefined(value), AssertionTypeDescription.nullOrUndefined, value),
+    object: (value) => assertType(is.object(value), 'Object', value),
+    iterable: (value) => assertType(is.iterable(value), AssertionTypeDescription.iterable, value),
+    asyncIterable: (value) => assertType(is.asyncIterable(value), AssertionTypeDescription.asyncIterable, value),
+    generator: (value) => assertType(is.generator(value), 'Generator', value),
+    asyncGenerator: (value) => assertType(is.asyncGenerator(value), 'AsyncGenerator', value),
+    nativePromise: (value) => assertType(is.nativePromise(value), AssertionTypeDescription.nativePromise, value),
+    promise: (value) => assertType(is.promise(value), 'Promise', value),
+    generatorFunction: (value) => assertType(is.generatorFunction(value), 'GeneratorFunction', value),
+    asyncGeneratorFunction: (value) => assertType(is.asyncGeneratorFunction(value), 'AsyncGeneratorFunction', value),
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    asyncFunction: (value) => assertType(is.asyncFunction(value), 'AsyncFunction', value),
+    // eslint-disable-next-line @typescript-eslint/ban-types
+    boundFunction: (value) => assertType(is.boundFunction(value), 'Function', value),
+    regExp: (value) => assertType(is.regExp(value), 'RegExp', value),
+    date: (value) => assertType(is.date(value), 'Date', value),
+    error: (value) => assertType(is.error(value), 'Error', value),
+    map: (value) => assertType(is.map(value), 'Map', value),
+    set: (value) => assertType(is.set(value), 'Set', value),
+    weakMap: (value) => assertType(is.weakMap(value), 'WeakMap', value),
+    weakSet: (value) => assertType(is.weakSet(value), 'WeakSet', value),
+    int8Array: (value) => assertType(is.int8Array(value), 'Int8Array', value),
+    uint8Array: (value) => assertType(is.uint8Array(value), 'Uint8Array', value),
+    uint8ClampedArray: (value) => assertType(is.uint8ClampedArray(value), 'Uint8ClampedArray', value),
+    int16Array: (value) => assertType(is.int16Array(value), 'Int16Array', value),
+    uint16Array: (value) => assertType(is.uint16Array(value), 'Uint16Array', value),
+    int32Array: (value) => assertType(is.int32Array(value), 'Int32Array', value),
+    uint32Array: (value) => assertType(is.uint32Array(value), 'Uint32Array', value),
+    float32Array: (value) => assertType(is.float32Array(value), 'Float32Array', value),
+    float64Array: (value) => assertType(is.float64Array(value), 'Float64Array', value),
+    bigInt64Array: (value) => assertType(is.bigInt64Array(value), 'BigInt64Array', value),
+    bigUint64Array: (value) => assertType(is.bigUint64Array(value), 'BigUint64Array', value),
+    arrayBuffer: (value) => assertType(is.arrayBuffer(value), 'ArrayBuffer', value),
+    sharedArrayBuffer: (value) => assertType(is.sharedArrayBuffer(value), 'SharedArrayBuffer', value),
+    dataView: (value) => assertType(is.dataView(value), 'DataView', value),
+    urlInstance: (value) => assertType(is.urlInstance(value), 'URL', value),
+    urlString: (value) => assertType(is.urlString(value), AssertionTypeDescription.urlString, value),
+    truthy: (value) => assertType(is.truthy(value), AssertionTypeDescription.truthy, value),
+    falsy: (value) => assertType(is.falsy(value), AssertionTypeDescription.falsy, value),
+    nan: (value) => assertType(is.nan(value), AssertionTypeDescription.nan, value),
+    primitive: (value) => assertType(is.primitive(value), AssertionTypeDescription.primitive, value),
+    integer: (value) => assertType(is.integer(value), AssertionTypeDescription.integer, value),
+    safeInteger: (value) => assertType(is.safeInteger(value), AssertionTypeDescription.safeInteger, value),
+    plainObject: (value) => assertType(is.plainObject(value), AssertionTypeDescription.plainObject, value),
+    typedArray: (value) => assertType(is.typedArray(value), AssertionTypeDescription.typedArray, value),
+    arrayLike: (value) => assertType(is.arrayLike(value), AssertionTypeDescription.arrayLike, value),
+    domElement: (value) => assertType(is.domElement(value), AssertionTypeDescription.domElement, value),
+    observable: (value) => assertType(is.observable(value), 'Observable', value),
+    nodeStream: (value) => assertType(is.nodeStream(value), AssertionTypeDescription.nodeStream, value),
+    infinite: (value) => assertType(is.infinite(value), AssertionTypeDescription.infinite, value),
+    emptyArray: (value) => assertType(is.emptyArray(value), AssertionTypeDescription.emptyArray, value),
+    nonEmptyArray: (value) => assertType(is.nonEmptyArray(value), AssertionTypeDescription.nonEmptyArray, value),
+    emptyString: (value) => assertType(is.emptyString(value), AssertionTypeDescription.emptyString, value),
+    nonEmptyString: (value) => assertType(is.nonEmptyString(value), AssertionTypeDescription.nonEmptyString, value),
+    emptyStringOrWhitespace: (value) => assertType(is.emptyStringOrWhitespace(value), AssertionTypeDescription.emptyStringOrWhitespace, value),
+    emptyObject: (value) => assertType(is.emptyObject(value), AssertionTypeDescription.emptyObject, value),
+    nonEmptyObject: (value) => assertType(is.nonEmptyObject(value), AssertionTypeDescription.nonEmptyObject, value),
+    emptySet: (value) => assertType(is.emptySet(value), AssertionTypeDescription.emptySet, value),
+    nonEmptySet: (value) => assertType(is.nonEmptySet(value), AssertionTypeDescription.nonEmptySet, value),
+    emptyMap: (value) => assertType(is.emptyMap(value), AssertionTypeDescription.emptyMap, value),
+    nonEmptyMap: (value) => assertType(is.nonEmptyMap(value), AssertionTypeDescription.nonEmptyMap, value),
+    propertyKey: (value) => assertType(is.propertyKey(value), 'PropertyKey', value),
+    formData: (value) => assertType(is.formData(value), 'FormData', value),
+    urlSearchParams: (value) => assertType(is.urlSearchParams(value), 'URLSearchParams', value),
+    // Numbers.
+    evenInteger: (value) => assertType(is.evenInteger(value), AssertionTypeDescription.evenInteger, value),
+    oddInteger: (value) => assertType(is.oddInteger(value), AssertionTypeDescription.oddInteger, value),
+    // Two arguments.
+    directInstanceOf: (instance, class_) => assertType(is.directInstanceOf(instance, class_), AssertionTypeDescription.directInstanceOf, instance),
+    inRange: (value, range) => assertType(is.inRange(value, range), AssertionTypeDescription.inRange, value),
+    // Variadic functions.
+    any: (predicate, ...values) => {
+        return assertType(is.any(predicate, ...values), AssertionTypeDescription.any, values, {
+            multipleValues: true,
+        });
+    },
+    all: (predicate, ...values) => assertType(is.all(predicate, ...values), AssertionTypeDescription.all, values, {
+        multipleValues: true,
+    }),
+};
+// Some few keywords are reserved, but we'll populate them for Node.js users
+// See https://github.com/Microsoft/TypeScript/issues/2536
+Object.defineProperties(is, {
+    class: {
+        value: is.class_,
+    },
+    function: {
+        value: is.function_,
+    },
+    null: {
+        value: is.null_,
+    },
+});
+Object.defineProperties(exports.assert, {
+    class: {
+        value: exports.assert.class_,
+    },
+    function: {
+        value: exports.assert.function_,
+    },
+    null: {
+        value: exports.assert.null_,
+    },
+});
+// export {Class, TypedArray, ObservableLike, Primitive} from './types';

package/dist-esm/array/array.util.js

@@ -237,4 +237,3 @@ export function _shuffle(array, mutate = false) {
 export function _last(array) {
     return array[array.length - 1];
 }
-//# sourceMappingURL=array.util.js.map

package/dist-esm/array/range.js

@@ -5,4 +5,3 @@ export function _range(fromIncl, toExcl, step = 1) {
     }
     return Array.from({ length: Math.ceil((toExcl - fromIncl) / step) }, (_, i) => i * step + fromIncl);
 }
-//# sourceMappingURL=range.js.map

package/dist-esm/decorators/createPromiseDecorator.js

@@ -82,4 +82,3 @@ export function _createPromiseDecorator(cfg, decoratorParams = {}) {
         return pd;
     };
 }
-//# sourceMappingURL=createPromiseDecorator.js.map

package/dist-esm/decorators/debounce.decorator.js

@@ -13,4 +13,3 @@ export function _Throttle(wait, opt = {}) {
         return descriptor;
     };
 }
-//# sourceMappingURL=debounce.decorator.js.map

package/dist-esm/decorators/debounce.js

@@ -107,4 +107,3 @@ export function _debounce(func, wait, opt = {}) {
 export function _throttle(func, wait, opt = {}) {
     return _debounce(func, wait, Object.assign(Object.assign({ leading: true, trailing: true }, opt), { maxWait: wait }));
 }
-//# sourceMappingURL=debounce.js.map

package/dist-esm/decorators/decorator.util.js

@@ -29,4 +29,3 @@ export function _getArgsSignature(args = [], noLogArgs = false) {
     })
         .join(', ');
 }
-//# sourceMappingURL=decorator.util.js.map

package/dist-esm/decorators/logMethod.decorator.js

@@ -85,4 +85,3 @@ function logFinished(callSignature, started, sma, logResultFn, res, err) {
     }
     console.log(t.filter(Boolean).join(' '));
 }
-//# sourceMappingURL=logMethod.decorator.js.map

package/dist-esm/decorators/memo.decorator.js

@@ -94,4 +94,3 @@ export const _Memo = (opt = {}) => (target, key, descriptor) => {
     };
     return descriptor;
 };
-//# sourceMappingURL=memo.decorator.js.map

package/dist-esm/decorators/memo.util.js

@@ -68,4 +68,3 @@ export class MapMemoCache {
         this.m.clear();
     }
 }
-//# sourceMappingURL=memo.util.js.map

package/dist-esm/decorators/memoFn.js

@@ -60,4 +60,3 @@ export function _memoFn(fn, opt = {}) {
     Object.assign(memoizedFn, { cache });
     return memoizedFn;
 }
-//# sourceMappingURL=memoFn.js.map

package/dist-esm/decorators/memoSimple.decorator.js

@@ -66,4 +66,3 @@ export const memoSimple = (opt = {}) => (target, key, descriptor) => {
     };
     return descriptor;
 };
-//# sourceMappingURL=memoSimple.decorator.js.map

package/dist-esm/decorators/retry.decorator.js

@@ -6,4 +6,3 @@ export function _Retry(opt = {}) {
         return descriptor;
     };
 }
-//# sourceMappingURL=retry.decorator.js.map

package/dist-esm/decorators/timeout.decorator.js

@@ -6,4 +6,3 @@ export function _Timeout(opt) {
         return descriptor;
     };
 }
-//# sourceMappingURL=timeout.decorator.js.map

package/dist-esm/error/app.error.js

@@ -28,4 +28,3 @@ export class AppError extends Error {
         }
     }
 }
-//# sourceMappingURL=app.error.js.map

package/dist-esm/error/assert.js

@@ -103,4 +103,3 @@ export class AssertionError extends AppError {
         }
     }
 }
-//# sourceMappingURL=assert.js.map

package/dist-esm/error/error.model.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=error.model.js.map

package/dist-esm/error/error.util.js

@@ -80,4 +80,3 @@ export function _isHttpErrorObject(o) {
 export function _isErrorObject(o) {
     return (typeof (o === null || o === void 0 ? void 0 : o.name) === 'string' && typeof (o === null || o === void 0 ? void 0 : o.message) === 'string' && typeof (o === null || o === void 0 ? void 0 : o.data) === 'object');
 }
-//# sourceMappingURL=error.util.js.map

package/dist-esm/error/errorMode.js

@@ -18,4 +18,3 @@ export var ErrorMode;
      */
     ErrorMode["SUPPRESS"] = "SUPPRESS";
 })(ErrorMode || (ErrorMode = {}));
-//# sourceMappingURL=errorMode.js.map

package/dist-esm/error/http.error.js

@@ -22,4 +22,3 @@ export class HttpError extends AppError {
         }
     }
 }
-//# sourceMappingURL=http.error.js.map

package/dist-esm/error/try.js

@@ -17,4 +17,3 @@ export function _try(fn) {
         return [err, undefined];
     }
 }
-//# sourceMappingURL=try.js.map

package/dist-esm/error/tryCatch.js

@@ -40,4 +40,3 @@ export const _TryCatch = (opt = {}) => (target, key, descriptor) => {
     descriptor.value = _tryCatch(originalFn, opt);
     return descriptor;
 };
-//# sourceMappingURL=tryCatch.js.map

package/dist-esm/index.js

@@ -16,6 +16,7 @@ import { ErrorMode } from './error/errorMode';
 import { HttpError } from './error/http.error';
 import { _try } from './error/try';
 import { _TryCatch, _tryCatch } from './error/tryCatch';
+import { generateJsonSchemaFromData } from './json-schema/from-data/generateJsonSchemaFromData';
 import { JSON_SCHEMA_ORDER } from './json-schema/jsonSchema.cnst';
 import { mergeJsonSchemaObjects } from './json-schema/jsonSchema.util';
 import { jsonSchema, JsonSchemaAnyBuilder, } from './json-schema/jsonSchemaBuilder';
@@ -46,5 +47,5 @@ import { _stringifyAny } from './string/stringifyAny';
 import { _ms, _since } from './time/time.util';
 import { _noop, _objectKeys, _passNothingPredicate, _passthroughMapper, _passthroughPredicate, _passUndefinedMapper, _stringMapEntries, _stringMapValues, } from './types';
 import { _gb, _hb, _kb, _mb } from './unit/size.util';
-export { _Memo, _memoFn, _LogMethod, _getArgsSignature, _createPromiseDecorator, AppError, HttpError, AssertionError, _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse, _assert, _assertEquals, _assertDeepEquals, _assertIsError, _assertIsString, _assertIsNumber, _assertTypeOf, _randomInt, _createDeterministicRandom, _inRange, _stringMapValues, _stringMapEntries, _objectKeys, _capitalize, _upperFirst, _lowerFirst, _split, _removeWhitespace, _substringBefore, _substringBeforeLast, _substringAfter, _substringAfterLast, _substringBetweenLast, _replaceAll, _nl2br, _truncate, _truncateMiddle, _pick, _omit, _filterFalsyValues, _filterUndefinedValues, _filterNullishValues, _filterEmptyArrays, _filterEmptyValues, _filterObject, _undefinedIfEmpty, _isObject, _isPrimitive, _mapKeys, _mapValues, _mapObject, _objectNullValuesToUndefined, _deepEquals, _deepCopy, _isEmptyObject, _isEmpty, _merge, _deepTrim, _sortObjectDeep, _sortObject, _get, _set, _has, _unset, _mask, _invert, _invertMap, _by, _groupBy, _sortBy, _sortNumbers, _toFixed, _toPrecision, _round, _findLast, _takeWhile, _takeRightWhile, _dropWhile, _dropRightWhile, _countBy, _intersection, _difference, _shuffle, _mapToObject, _findKeyByValue, _anyToError, _anyToErrorObject, _errorToErrorObject, _errorObjectToAppError, _range, _uniq, _uniqBy, _flatten, _flattenDeep, _chunk, SimpleMovingAverage, _average, _averageWeighted, _percentile, _median, _debounce, _throttle, _Debounce, _Throttle, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, pBatch, ErrorMode, pFilter, pProps, pDelay, pDefer, pHang, pState, AggregatedError, pRetry, pTimeout, pTuple, _Retry, _Timeout, _tryCatch, _TryCatch, _try, _jsonParseIfPossible, _stringifyAny, _ms, _since, _hb, _gb, _mb, _kb, _snakeCase, _camelCase, _kebabCase, _sum, _sumBy, _clamp, _last, mergeJsonSchemaObjects, jsonSchema, JsonSchemaAnyBuilder, JSON_SCHEMA_ORDER, };
-//# sourceMappingURL=index.js.map
+import { is } from './vendor/is';
+export { is, _Memo, _memoFn, _LogMethod, _getArgsSignature, _createPromiseDecorator, AppError, HttpError, AssertionError, _isErrorObject, _isHttpErrorObject, _isHttpErrorResponse, _assert, _assertEquals, _assertDeepEquals, _assertIsError, _assertIsString, _assertIsNumber, _assertTypeOf, _randomInt, _createDeterministicRandom, _inRange, _stringMapValues, _stringMapEntries, _objectKeys, _capitalize, _upperFirst, _lowerFirst, _split, _removeWhitespace, _substringBefore, _substringBeforeLast, _substringAfter, _substringAfterLast, _substringBetweenLast, _replaceAll, _nl2br, _truncate, _truncateMiddle, _pick, _omit, _filterFalsyValues, _filterUndefinedValues, _filterNullishValues, _filterEmptyArrays, _filterEmptyValues, _filterObject, _undefinedIfEmpty, _isObject, _isPrimitive, _mapKeys, _mapValues, _mapObject, _objectNullValuesToUndefined, _deepEquals, _deepCopy, _isEmptyObject, _isEmpty, _merge, _deepTrim, _sortObjectDeep, _sortObject, _get, _set, _has, _unset, _mask, _invert, _invertMap, _by, _groupBy, _sortBy, _sortNumbers, _toFixed, _toPrecision, _round, _findLast, _takeWhile, _takeRightWhile, _dropWhile, _dropRightWhile, _countBy, _intersection, _difference, _shuffle, _mapToObject, _findKeyByValue, _anyToError, _anyToErrorObject, _errorToErrorObject, _errorObjectToAppError, _range, _uniq, _uniqBy, _flatten, _flattenDeep, _chunk, SimpleMovingAverage, _average, _averageWeighted, _percentile, _median, _debounce, _throttle, _Debounce, _Throttle, pMap, _passthroughMapper, _passUndefinedMapper, _passthroughPredicate, _passNothingPredicate, _noop, pBatch, ErrorMode, pFilter, pProps, pDelay, pDefer, pHang, pState, AggregatedError, pRetry, pTimeout, pTuple, _Retry, _Timeout, _tryCatch, _TryCatch, _try, _jsonParseIfPossible, _stringifyAny, _ms, _since, _hb, _gb, _mb, _kb, _snakeCase, _camelCase, _kebabCase, _sum, _sumBy, _clamp, _last, mergeJsonSchemaObjects, jsonSchema, JsonSchemaAnyBuilder, JSON_SCHEMA_ORDER, generateJsonSchemaFromData, };