@tstdl/base 0.90.57 → 0.90.59

package/utils/format.js

@@ -1,22 +1,23 @@
+import { kibibyte, kilobyte, microsecondsPerMillisecond, millisecondsPerSecond, nanosecondsPerMillisecond } from './units.js';
 const siByteSizes = ['B', 'kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
 const iecByteSizes = ['B', 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
 export function formatDuration(milliseconds, precision) {
     let value;
     let suffix;
-    if (milliseconds >= (10 ** 3)) {
-        value = milliseconds / (10 ** 3);
+    if (milliseconds >= millisecondsPerSecond) {
+        value = milliseconds / millisecondsPerSecond;
         suffix = 's';
     }
     else if (milliseconds >= 1) {
         value = milliseconds;
         suffix = 'ms';
     }
-    else if (milliseconds >= 1 / (10 ** 3)) {
-        value = milliseconds * (10 ** 3);
+    else if (milliseconds >= 1 / microsecondsPerMillisecond) {
+        value = milliseconds * microsecondsPerMillisecond;
         suffix = 'us';
     }
     else {
-        value = milliseconds * (10 ** 6);
+        value = milliseconds * nanosecondsPerMillisecond;
         suffix = 'ns';
     }
     const trimmed = parseFloat(value.toFixed(precision));
@@ -25,7 +26,7 @@ export function formatDuration(milliseconds, precision) {
 }
 export function formatBytes(bytes, { decimals = 2, unit = 'IEC' } = {}) {
     const iec = unit == 'IEC';
-    const base = iec ? 1024 : 1000;
+    const base = iec ? kibibyte : kilobyte;
     const exponent = Math.floor(Math.log(bytes) / Math.log(base));
     const prefix = (iec ? iecByteSizes : siByteSizes)[exponent];
     const result = (bytes / (base ** exponent));

package/utils/helpers.d.ts

@@ -1,6 +1,6 @@
 import type { DeepArray, Record } from '../types.js';
 /**
- * create an structured clone of an value using Notification if available, otherwise history state (may alters history)
+ * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
  *
  * may not work in every environment!
  * @param value value to clone
@@ -8,7 +8,7 @@ import type { DeepArray, Record } from '../types.js';
  */
 export declare function structuredClone<T>(value: T): T;
 /**
- * create an structured clone of an value using a MessageChannel
+ * Create an structured clone of an value using a MessageChannel
  *
  * should work in all environments
  * @param value value to clone
@@ -27,39 +27,39 @@ export declare function parseFirstAndFamilyName(name: string): {
 };
 export type NormalizeTextOptions = {
     /**
-     * remove leading and trailing whitespace
+     * Remove leading and trailing whitespace
      */
     trim?: boolean;
     /**
-     * lowercase all characters
+     * Lowercase all characters
      */
     lowercase?: boolean;
     /**
-     * remove multiple consecutive whitespace characters
+     * Remove multiple consecutive whitespace characters
      */
     multipleWhitespace?: boolean;
     /**
-     * remove diacritics (è -> e)
+     * Remove diacritics (è -> e)
      *
      * applies unicode NFD normalization and removes diacritics
      * @see unicode option
      */
     diacritics?: boolean;
     /**
-     * replace ligatures with their consecutive characters (æ -> ae)
+     * Replace ligatures with their consecutive characters (æ -> ae)
      *
      * applies unicode NFKC normalization
      * @see unicode option
      */
     ligatures?: boolean;
     /**
-     * unicode normalization
+     * Unicode normalization
      * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize
      */
     unicode?: 'NFC' | 'NFD' | 'NFKC' | 'NFKD';
 };
 /**
- * trims, lowercases, replaces multi-character whitespace with a single space and unicode normalization
+ * Trims, lowercases, replaces multi-character whitespace with a single space and unicode normalization
  * @param text text to normalize
  * @param options specify what to normalize. Defaults to all except unicode
  * @returns normalized text

package/utils/helpers.js

@@ -4,7 +4,7 @@ import { DetailsError } from '../errors/details.error.js';
 import { decycle } from './object/decycle.js';
 import { isDefined } from './type-guards.js';
 /**
- * create an structured clone of an value using Notification if available, otherwise history state (may alters history)
+ * Create an structured clone of an value using Notification if available, otherwise history state (may alters history)
  *
  * may not work in every environment!
  * @param value value to clone
@@ -21,7 +21,7 @@ export function structuredClone(value) {
     return copy;
 }
 /**
- * create an structured clone of an value using a MessageChannel
+ * Create an structured clone of an value using a MessageChannel
  *
  * should work in all environments
  * @param value value to clone
@@ -70,7 +70,7 @@ export function parseFirstAndFamilyName(name) {
     };
 }
 /**
- * trims, lowercases, replaces multi-character whitespace with a single space and unicode normalization
+ * Trims, lowercases, replaces multi-character whitespace with a single space and unicode normalization
  * @param text text to normalize
  * @param options specify what to normalize. Defaults to all except unicode
  * @returns normalized text

package/utils/object/decycle.d.ts

@@ -3,13 +3,13 @@ export type Decycled<T> = {
     __type: T;
 } & Record<string>;
 /**
- * replaces cycles (circular references) in objects with JSONPath
+ * Replaces cycles (circular references) in objects with JSONPath
  * @param value object to decycle
  * @param replacer replace values. Like JSON.stringify(value, *replacer*)
  */
 export declare function decycle<T>(value: T, replacer?: (value: any) => any): Decycled<T>;
 /**
- * replaces JSONPath in objects with their reference
+ * Replaces JSONPath in objects with their reference
  * @param value object to recycle
  */
 export declare function recycle<T = any>(value: Decycled<T>, clone?: boolean): T;

package/utils/object/decycle.js

@@ -6,7 +6,7 @@ import { hasOwnProperty, mapObjectValues, objectKeys } from './object.js';
 export function decycle(_value, replacer) {
     const mapping = new Map();
     const replacerFn = isDefined(replacer) ? replacer : (value) => value;
-    function _decycle(__value, path) {
+    function decycleInternal(__value, path) {
         const value = replacerFn(__value);
         if (isPrimitive(value) || isRegExp(value) || isDate(value) || isFunction(value)) {
             return value;
@@ -17,11 +17,11 @@ export function decycle(_value, replacer) {
         }
         mapping.set(value, path);
         if (isArray(value)) {
-            return value.map((item, index) => _decycle(item, path.add(index)));
+            return value.map((item, index) => decycleInternal(item, path.add(index)));
         }
-        return mapObjectValues(value, (item, key) => _decycle(item, path.add(key)));
+        return mapObjectValues(value, (item, key) => decycleInternal(item, path.add(key)));
     }
-    return _decycle(_value, JsonPath.ROOT);
+    return decycleInternal(_value, JsonPath.ROOT);
 }
 export function recycle(_value, _clone = true) {
     const value = _clone ? clone(_value, true) : _value;
@@ -35,7 +35,7 @@ export function recycle(_value, _clone = true) {
         }
         return undefined;
     }
-    function _recycle(node) {
+    function recycleInternal(node) {
         if (isWritableArray(node)) {
             for (let i = 0; i < node.length; i++) {
                 const ref = getRef(node[i]);
@@ -43,7 +43,7 @@ export function recycle(_value, _clone = true) {
                     node[i] = deref(value, ref);
                 }
                 else {
-                    _recycle(node[i]);
+                    recycleInternal(node[i]);
                 }
             }
         }
@@ -54,11 +54,11 @@ export function recycle(_value, _clone = true) {
                     node[key] = deref(value, ref);
                 }
                 else {
-                    _recycle(node[key]);
+                    recycleInternal(node[key]);
                 }
             }
         }
     }
-    _recycle(value);
+    recycleInternal(value);
     return value;
 }

package/utils/object/dereference.d.ts

@@ -1,14 +1,14 @@
-import type { JsonPathInput } from '../../json-path/index.js';
+import { type JsonPathInput } from '../../json-path/index.js';
 export type CompiledDereferencer = (object: object) => unknown;
 /**
- * compiles a dereferencer for a specific reference
+ * Compiles a dereferencer for a specific reference
  * @param object object to dereference
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
 export declare function compileDereferencer(reference: JsonPathInput): (object: object) => unknown;
 /**
- * dereference a reference
+ * Dereference a reference
  *
  * @description useful if you dereference a reference a few times at most
  *
@@ -19,7 +19,7 @@ export declare function compileDereferencer(reference: JsonPathInput): (object:
  */
 export declare function dereference(object: object, reference: JsonPathInput): unknown;
 /**
- * cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
  *
  * @description
  * useful if you dereference multiple references, each multiple times

package/utils/object/dereference.js

@@ -1,13 +1,13 @@
 import { JsonPath } from '../../json-path/index.js';
 import { memoizeSingle } from '../function/memoize.js';
 /**
- * compiles a dereferencer for a specific reference
+ * Compiles a dereferencer for a specific reference
  * @param object object to dereference
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
 export function compileDereferencer(reference) {
-    const nodes = new JsonPath(reference).nodes;
+    const nodes = JsonPath.from(reference).nodes;
     function dereferencer(object) {
         let target = object;
         for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
@@ -18,7 +18,7 @@ export function compileDereferencer(reference) {
     return dereferencer;
 }
 /**
- * dereference a reference
+ * Dereference a reference
  *
  * @description useful if you dereference a reference a few times at most
  *
@@ -31,7 +31,7 @@ export function dereference(object, reference) {
     return compileDereferencer(reference)(object);
 }
 /**
- * cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
+ * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
  *
  * @description
  * useful if you dereference multiple references, each multiple times

package/utils/object/forward-ref.js

@@ -54,9 +54,9 @@ function getForwardRefProxy(context) {
 }
 function getContext(options) {
     const reference = isDefined(options?.reference)
-        ? { value: options?.reference }
+        ? { value: options.reference }
         : isDefined(options?.initializer)
-            ? { initializer: options?.initializer }
+            ? { initializer: options.initializer }
             : { value: undefined };
     return lazyObject({
         reference

package/utils/object/lazy-property.d.ts

@@ -1,34 +1,34 @@
-import type { IfUnknown } from '../../types.js';
+import type { AnyFunction, IfUnknown } from '../../types.js';
 declare const lazyObjectValueSymbol: unique symbol;
 export type LazyPropertyInitializer<T, K extends keyof T> = (this: T, key: K) => T[K];
 export type LazyPropertyObjectDefinition<T extends object, P extends keyof T> = LazyPropertyDescriptor & {
-    /** define property with existing value */
+    /** Define property with existing value */
     value?: T[P];
-    /** define property with getter */
+    /** Define property with getter */
     get?: (this: T) => T[P];
-    /** define property with setter */
+    /** Define property with setter */
     set?: (this: T, value: T[P]) => void;
-    /** lazily define property with initializer */
+    /** Lazily define property with initializer */
     initializer?: LazyPropertyInitializer<T, P>;
 };
 export type LazyObjectValue<T> = {
     [lazyObjectValueSymbol]: typeof lazyObjectValueSymbol;
     value: T;
 };
-export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, Function | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
+export type LazyInitializerItem<T extends object, P extends keyof T> = Exclude<IfUnknown<T[P], never, T[P]>, AnyFunction | object> | LazyPropertyInitializer<T, P> | LazyPropertyObjectDefinition<T, P> | LazyObjectValue<T[P]>;
 export type LazyPropertyDescriptor = {
     /**
-     * true if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object
+     * True if the type of this property descriptor may be changed and if the property may be deleted from the corresponding object
      * @default true
      */
     configurable?: boolean;
     /**
-     * true if and only if this property shows up during enumeration of the properties on the corresponding object
+     * True if and only if this property shows up during enumeration of the properties on the corresponding object
      * @default true
      */
     enumerable?: boolean;
     /**
-     * true if the value associated with the property may be changed with an assignment operator
+     * True if the value associated with the property may be changed with an assignment operator
      * @default true
      */
     writable?: boolean;

package/utils/object/lazy-property.js

@@ -23,14 +23,15 @@ export function lazyProperty(object, propertyKey, initializer, descriptor = {})
             }
             return _value;
         },
-        set: !writable ? undefined
-            : function set(value) {
+        set: writable
+            ? function set(value) {
                 if (configurable) {
                     Object.defineProperty(object, propertyKey, { configurable, enumerable, writable, value });
                 }
                 _value = value;
                 initialized = true;
-            },
+            }
+            : undefined,
         enumerable,
         configurable
     });

package/utils/object/merge.d.ts

@@ -1,6 +1,6 @@
 export type MergeObjectsOptions = {
     /**
-     * whether to merge arrays or ensure they are equal
+     * Whether to merge arrays or ensure they are equal
      * @default 'merge'
      */
     array?: 'merge' | 'merge-unique' | 'equals' | 'equals-sorted';

package/utils/object/merge.js

@@ -3,9 +3,9 @@ import { arrayEquals } from '../equals.js';
 import { isArray, isPrimitive, isUndefined } from '../type-guards.js';
 import { hasOwnProperty, objectEntries } from './object.js';
 export function mergeObjects(objects, options = {}) {
-    return objects.reduce((merged, object) => _mergeObjects(merged, object, options), {});
+    return objects.reduce((merged, object) => mergeObjectsInternal(merged, object, options), {});
 }
-function _mergeObjects(a, b, options, path = '$') {
+function mergeObjectsInternal(a, b, options, path = '$') {
     const merged = { ...a };
     const bEntries = objectEntries(b);
     for (const [key, valueB] of bEntries) {
@@ -36,7 +36,7 @@ function mergeValues(a, b, options, path) {
         }
         return mergeArray(a, b, options, path); // eslint-disable-line @typescript-eslint/no-unsafe-return
     }
-    return _mergeObjects(a, b, options, path);
+    return mergeObjectsInternal(a, b, options, path);
 }
 function mergeArray(a, b, options, path) {
     if (options.array == 'merge' || isUndefined(options.array)) {

package/utils/object/object.d.ts

@@ -2,11 +2,11 @@ import type { FromEntries, ObjectLiteral, PickBy, Record, SimplifyObject } from
 import type { IsEqual } from 'type-fest';
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
- * returns object entries including those with symbols keys (which Object.entries does not)
+ * Returns object entries including those with symbols keys (which Object.entries does not)
  */
 export declare function objectEntries<T extends ObjectLiteral>(object: T): [keyof T, T[keyof T]][];
 /**
- * returns object keys including symbols (which Object.keys does not)
+ * Returns object keys including symbols (which Object.keys does not)
  */
 export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T)[];
 export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];

package/utils/object/object.js

@@ -6,14 +6,14 @@ export function hasOwnProperty(obj, key) {
     return Object.hasOwn(obj, key);
 }
 /**
- * returns object entries including those with symbols keys (which Object.entries does not)
+ * Returns object entries including those with symbols keys (which Object.entries does not)
  */
 export function objectEntries(object) {
     const keys = objectKeys(object);
     return keys.map((key) => [key, object[key]]);
 }
 /**
- * returns object keys including symbols (which Object.keys does not)
+ * Returns object keys including symbols (which Object.keys does not)
  */
 export function objectKeys(object) {
     return Reflect.ownKeys(object).filter((key) => key != '__proto__');

package/utils/object/property-name.d.ts

@@ -8,26 +8,26 @@ export type PropertyNameProxy<T extends Record> = {
     [P in keyof DeepNonNullable<T>]: PropertyNameProxyChild<T[P]>;
 };
 export type PropertyNameProxyChild<T> = (T extends Record ? (PropertyNameProxy<T> & PropertyName) : (PropertyName)) & {
-    [cast]: <U extends T>() => PropertyNameProxyChild<U>;
+    [cast]<U extends T>(): PropertyNameProxyChild<U>;
 };
 export type PropertyNameOfExpressionObject<T> = {
     [P in keyof T]: PropertyNameOfExpressionObject<DeepNonNullable<T>[P]> & {
-        [cast]: <U extends T[P]>() => PropertyNameOfExpressionObject<DeepNonNullable<U>>;
+        [cast]<U extends T[P]>(): PropertyNameOfExpressionObject<DeepNonNullable<U>>;
     };
 };
 export type FlatPropertyNameOfExpressionObject<T> = {
     [P in keyof DeepFlatten<T>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
-        [cast]: <U extends DeepFlatten<T>[P]>() => FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
+        [cast]<U extends DeepFlatten<T>[P]>(): FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
     };
 };
 export declare function getPropertyName(name: string): PropertyName;
 export declare function isPropertyName(value: any): value is PropertyName;
 /**
- * get the path to a property
+ * Get the path to a property
  *
- * @param options.deep whether to return the whole path to the property or just the last property
- * @param options.flat ignore array accesses (properties consiting only of numbers)
- * @param options.prefix name prefix
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @param options.flat Ignore array accesses (properties consiting only of numbers)
+ * @param options.prefix Name prefix
  *
  * @example
  * import { getPropertyNameProxy, propertyName } from '@tstdl/base/utils/object.js';
@@ -42,19 +42,19 @@ export declare function getPropertyNameProxy<T extends Record = Record>(options?
     prefix?: string;
 }): PropertyNameProxy<T>;
 /**
- * get the path to a property
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
+ * Get the path to a property
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
  */
 export declare function propertyNameOf<T extends Record = Record>(expression: (instance: PropertyNameOfExpressionObject<T>) => any, options?: {
     deep?: boolean;
 }): string;
 /**
- * get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
+ * Get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
  */
 export declare function flatPropertyNameOf<T extends Record = Record>(expression: (instance: FlatPropertyNameOfExpressionObject<T>) => any, options?: {
     deep?: boolean;

package/utils/object/property-name.js

@@ -9,11 +9,11 @@ export function isPropertyName(value) {
 }
 const propertyNameProxy = Symbol('PropertyNameProxy');
 /**
- * get the path to a property
+ * Get the path to a property
  *
- * @param options.deep whether to return the whole path to the property or just the last property
- * @param options.flat ignore array accesses (properties consiting only of numbers)
- * @param options.prefix name prefix
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @param options.flat Ignore array accesses (properties consiting only of numbers)
+ * @param options.prefix Name prefix
  *
  * @example
  * import { getPropertyNameProxy, propertyName } from '@tstdl/base/utils/object.js';
@@ -53,20 +53,20 @@ export function getPropertyNameProxy(options = {}) {
     return proxy;
 }
 /**
- * get the path to a property
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
+ * Get the path to a property
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
  */
 export function propertyNameOf(expression, options = {}) {
     const name = expression(getPropertyNameProxy({ deep: options.deep, flat: false }))?.[propertyName];
     return assertStringPass(name, 'invalid expression');
 }
 /**
- * get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
- * @param expression property selection expression
- * @param options.deep whether to return the whole path to the property or just the last property
- * @returns property name
+ * Get the flat path to a property (flat = ignore array accesses (properties only consisting of numbers))
+ * @param expression Property selection expression
+ * @param options.deep Whether to return the whole path to the property or just the last property
+ * @returns Property name
  */
 export function flatPropertyNameOf(expression, options = {}) {
     const name = expression(getPropertyNameProxy({ deep: options.deep, flat: true }))?.[propertyName];

package/utils/patch-worker.d.ts

@@ -1,12 +1,12 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 import type { Record, StringMap } from '../types.js';
 export type PatchWorkerOptions<T extends StringMap> = {
     debounceTime?: number;
     retryDelay?: number;
     handleOn?: Observable<any>;
     completeOn?: Observable<any>;
-    handler: (patch: Partial<T>) => void | Promise<void>;
-    errorHandler?: (error: Error) => void | Promise<void>;
+    handler(patch: Partial<T>): void | Promise<void>;
+    errorHandler?(error: Error): void | Promise<void>;
 };
 export declare class PatchWorker<T extends Record> {
     private readonly patchAddedSubject;

package/utils/patterns.d.ts

@@ -1,5 +1,5 @@
-/** pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
+/** Pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
 export declare const numberPattern: RegExp;
-/** pattern matching valid email addresses */
+/** Pattern matching valid email addresses */
 export declare const mailPattern: RegExp;
 export declare function isEmail(value: string): boolean;

package/utils/patterns.js

@@ -1,7 +1,7 @@
-/** pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
+/** Pattern matching valid JavaScript number literals including binary, octal and hexadecimal format but *not* Infinity and NaN */
 export const numberPattern = /^[+-]?(?:\d*\.?\d+|\d+\.?\d*|0[bB][01]+|0[xX][\da-fA-F]+|0[oO][0-7]+)$/u;
-/** pattern matching valid email addresses */
-// eslint-disable-next-line no-control-regex
+/** Pattern matching valid email addresses */
+// eslint-disable-next-line no-control-regex, prefer-named-capture-group
 export const mailPattern = /^(?:[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-zA-Z0-9-]*[a-zA-Z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])$/u;
 export function isEmail(value) {
     return mailPattern.test(value);

package/utils/periodic-reporter.d.ts

@@ -1,4 +1,4 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export declare class PeriodicReporter {
     private readonly reportSubject;
     private readonly interval;

package/utils/periodic-sampler.d.ts

@@ -1,4 +1,4 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export declare enum AggregationMode {
     Minimum = 0,
     Maximum = 1,

package/utils/periodic-sampler.js

@@ -1,5 +1,4 @@
-import { Subject } from 'rxjs';
-import { bufferCount, filter, map } from 'rxjs';
+import { Subject, bufferCount, filter, map } from 'rxjs';
 import { compareByValue } from './comparison.js';
 import { average } from './math.js';
 import { timeout } from './timing.js';
@@ -55,18 +54,21 @@ function aggregate(aggregation, values) {
             return Math.max(...values);
         case AggregationMode.Mean:
             return average(values);
-        case AggregationMode.Median:
+        case AggregationMode.Median: {
             values.sort(compareByValue);
             const median = Math.floor(values.length / 2);
             return values[median];
-        case AggregationMode.FirstQuartile:
+        }
+        case AggregationMode.FirstQuartile: {
             values.sort(compareByValue);
             const firstQuartile = Math.floor(values.length / 4 * 1);
             return values[firstQuartile];
-        case AggregationMode.ThirdQuartile:
+        }
+        case AggregationMode.ThirdQuartile: {
             values.sort(compareByValue);
             const thirdQuartile = Math.floor(values.length / 4 * 3);
             return values[thirdQuartile];
+        }
         default:
             throw new Error(`aggregation mode ${aggregation} not implemented`);
     }

package/utils/random.d.ts

@@ -1,5 +1,5 @@
 /**
- * generate cryptographically secure random bytes
+ * Generate cryptographically secure random bytes
  *
  * if allowUnsafe is true a view on the underlying pool is returned. This can be dangerous as the underlying
  * pool can be read and modified by other callers of {@link getRandomBytes} but improves performance as
@@ -9,7 +9,7 @@
  */
 export declare function getRandomBytes(count: number, allowUnsafe?: boolean): Uint8Array;
 /**
- * generate a cryptographically secure random string (in terms of source of randomness).
+ * Generate a cryptographically secure random string (in terms of source of randomness).
  * @param length length of string
  * @param alphabet alphabet to choose characters from. Defaults to {@link Alphabet.LowerUpperCaseNumbers}
  */

package/utils/random.js

@@ -4,7 +4,7 @@ const bufferBypassThreshold = (bufferSize / 2) + 1;
 let randomBytesBuffer = new Uint8Array();
 let randomBytesBufferIndex = 0;
 /**
- * generate cryptographically secure random bytes
+ * Generate cryptographically secure random bytes
  *
  * if allowUnsafe is true a view on the underlying pool is returned. This can be dangerous as the underlying
  * pool can be read and modified by other callers of {@link getRandomBytes} but improves performance as
@@ -26,7 +26,7 @@ export function getRandomBytes(count, allowUnsafe = false) {
     return bytes;
 }
 /**
- * generate a cryptographically secure random string (in terms of source of randomness).
+ * Generate a cryptographically secure random string (in terms of source of randomness).
  * @param length length of string
  * @param alphabet alphabet to choose characters from. Defaults to {@link Alphabet.LowerUpperCaseNumbers}
  */

package/utils/reactive-value-to-signal.d.ts

@@ -1,4 +1,4 @@
-import type { Signal, ToSignalOptions } from '../signals/api.js';
+import { type Signal, type ToSignalOptions } from '../signals/api.js';
 import type { ReactiveValue } from '../types.js';
 export type ReactiveValueToSignalOptions = ToSignalOptions;
 export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>): Signal<T | undefined>;