@tstdl/base 0.90.57 → 0.90.59

package/search-index/elastic/query-builder/boolean-query-builder.js

@@ -1,52 +1,52 @@
 export class BoolQueryBuilder {
-    _must;
-    _should;
-    _mustNot;
-    _filter;
+    #must;
+    #should;
+    #mustNot;
+    #filter;
     get totalQueries() {
-        return this._must.length + this._should.length + this._mustNot.length + this._filter.length;
+        return this.#must.length + this.#should.length + this.#mustNot.length + this.#filter.length;
     }
     constructor() {
-        this._must = [];
-        this._should = [];
-        this._mustNot = [];
-        this._filter = [];
+        this.#must = [];
+        this.#should = [];
+        this.#mustNot = [];
+        this.#filter = [];
     }
     build() {
         const queryObj = {
             bool: {}
         };
-        if (this._must.length > 0) {
-            queryObj.bool.must = this._must;
+        if (this.#must.length > 0) {
+            queryObj.bool.must = this.#must;
         }
-        if (this._should.length > 0) {
-            queryObj.bool.should = this._should;
+        if (this.#should.length > 0) {
+            queryObj.bool.should = this.#should;
         }
-        if (this._mustNot.length > 0) {
-            queryObj.bool.must_not = this._mustNot;
+        if (this.#mustNot.length > 0) {
+            queryObj.bool.must_not = this.#mustNot;
         }
-        if (this._filter.length > 0) {
-            queryObj.bool.filter = this._filter;
+        if (this.#filter.length > 0) {
+            queryObj.bool.filter = this.#filter;
         }
-        if (this._mustNot.length == 0 && (this._must.length + this._should.length + this._filter.length) == 1) {
-            return [...this._must, ...this._should, ...this._filter][0];
+        if (this.#mustNot.length == 0 && (this.#must.length + this.#should.length + this.#filter.length) == 1) {
+            return [...this.#must, ...this.#should, ...this.#filter][0];
         }
         return queryObj;
     }
     must(...queries) {
-        this._must.push(...queries);
+        this.#must.push(...queries);
         return this;
     }
     should(...queries) {
-        this._should.push(...queries);
+        this.#should.push(...queries);
         return this;
     }
     mustNot(...queries) {
-        this._mustNot.push(...queries);
+        this.#mustNot.push(...queries);
         return this;
     }
     filter(...queries) {
-        this._filter.push(...queries);
+        this.#filter.push(...queries);
         return this;
     }
 }

package/templates/renderers/jsx.template-renderer.d.ts

@@ -6,5 +6,5 @@ export type JsxTemplateRenderObject = TemplateRenderObject<'jsx', undefined, Jsx
 export declare class JsxTemplateRenderer extends TemplateRenderer<'jsx', undefined> {
     constructor();
     canHandleType(type: string): boolean;
-    _render({ template }: JsxTemplateRenderObject, context: Record): TemplateRenderResult;
+    _render({ template }: JsxTemplateRenderObject, context: Record): Promise<TemplateRenderResult>;
 }

package/templates/renderers/jsx.template-renderer.js

@@ -8,7 +8,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { Singleton } from '../../injector/decorators.js';
-import { renderJsx } from '../../jsx/render-to-string.js';
+import { renderJsxAsync } from '../../jsx/render-to-string.js';
 import { TemplateRenderer } from '../template.renderer.js';
 let JsxTemplateRenderer = class JsxTemplateRenderer extends TemplateRenderer {
     constructor() {
@@ -17,8 +17,8 @@ let JsxTemplateRenderer = class JsxTemplateRenderer extends TemplateRenderer {
     canHandleType(type) {
         return (type == 'jsx');
     }
-    _render({ template }, context) {
-        return renderJsx(template, context);
+    async _render({ template }, context) {
+        return renderJsxAsync(template, context);
     }
 };
 JsxTemplateRenderer = __decorate([

package/theme/theme-service.d.ts

@@ -1,4 +1,4 @@
-import type { Observable } from 'rxjs';
+import { type Observable } from 'rxjs';
 export type CalculatedPalette<Colors extends string = string> = {
     [Color in Colors]: ColorTonesWithRgb;
 };

package/theme/theme-service.js

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-magic-numbers */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -81,8 +82,8 @@ function _generateColorTones(base) {
 function toColorTonesWithRgb(tones) {
     return {
         /* eslint-disable @typescript-eslint/naming-convention, quote-props */
-        base: tones.base,
-        baseRgb: getRgbString(tones.base),
+        'base': tones.base,
+        'baseRgb': getRgbString(tones.base),
         '50': tones['50'],
         '50Rgb': getRgbString(tones['50']),
         '100': tones['100'],

package/types.d.ts

@@ -3,14 +3,14 @@ import type { CamelCase, Except } from 'type-fest';
 import type { Signal } from './signals/api.js';
 export type ObjectLiteral = {};
 export type PrimitiveTypeMap = {
-    'string': string;
-    'number': number;
-    'boolean': boolean;
-    'bigint': bigint;
-    'symbol': symbol;
-    'object': object;
-    'function': Function;
-    'undefined': undefined;
+    string: string;
+    number: number;
+    boolean: boolean;
+    bigint: bigint;
+    symbol: symbol;
+    object: object;
+    function: Function;
+    undefined: undefined;
 };
 export type PrimitiveTypeString<T extends PrimitiveTypeMap[keyof PrimitiveTypeMap] = PrimitiveTypeMap[keyof PrimitiveTypeMap]> = Simplify<keyof PickBy<PrimitiveTypeMap, T>>;
 export type PrimitiveType<T extends keyof PrimitiveTypeMap = keyof PrimitiveTypeMap> = Simplify<PrimitiveTypeMap[T]>;
@@ -105,13 +105,13 @@ export type OmitNever<T extends Record> = {
 };
 export type SharedProperties<A, B, C = unknown, D = unknown, E = unknown, F = unknown, G = unknown, H = unknown, I = unknown, J = unknown> = OmitNever<Pick<A & B & C & D & E & F & G & H & I & J, keyof A & keyof B & keyof ReplaceIfUnknown<C, never> & keyof ReplaceIfUnknown<D, never> & keyof ReplaceIfUnknown<E, never> & keyof ReplaceIfUnknown<F, never> & keyof ReplaceIfUnknown<G, never> & keyof ReplaceIfUnknown<H, never> & keyof ReplaceIfUnknown<I, never> & keyof ReplaceIfUnknown<J, never>>>;
 /**
- * omit properties from a type that extend from a specific type.
+ * Omit properties from a type that extend from a specific type.
  */
 export type OmitBy<T, V> = Omit<T, {
     [K in keyof T]: V extends Extract<T[K], V> ? K : never;
 }[keyof T]>;
 /**
- * normalize properties of a type that allow `undefined` to make them optional.
+ * Normalize properties of a type that allow `undefined` to make them optional.
  */
 export type Optionalize<T extends object> = OmitBy<T, undefined> & Partial<PickBy<T, undefined>>;
 export type SimplifiedOptionalize<T extends object> = SimplifyObject<Optionalize<T>>;
@@ -137,7 +137,7 @@ export type UndefinableObject<T extends Record> = {
     [K in keyof T]: T[K] | undefined;
 };
 /**
- * pick properties from a type that extend from a specific type.
+ * Pick properties from a type that extend from a specific type.
  */
 export type PickBy<T, V> = Pick<T, {
     [K in keyof T]: V extends Extract<T[K], V> ? K : never;
@@ -146,7 +146,7 @@ export type NonNullable<T> = T extends null ? never : T;
 export type NonUndefinable<T> = T extends undefined ? never : T;
 export type NonNullOrUndefinable<T> = T extends null | undefined ? never : T;
 /**
- * makes optional properties required and removes null and undefined
+ * Makes optional properties required and removes null and undefined
  */
 export type DeepNonNullable<T> = T extends Record ? {
     [P in keyof T]-?: DeepNonNullable<T[P]>;
@@ -194,4 +194,18 @@ export type TypeFromPath<T extends Record, Path extends Paths<T> | string> = {
 export type ConstructorParameterDecorator = (target: Object, propertyKey: undefined, parameterIndex: number) => void;
 export type ReactiveValue<T> = T | Signal<T> | Observable<T>;
 export type PascalCase<Value> = CamelCase<Value> extends string ? Capitalize<CamelCase<Value>> : CamelCase<Value>;
+type PickOmitDeepSelection<T> = T extends (infer U)[] ? (boolean | PickOmitDeepSelection<U>) : T extends Record<any> ? (boolean | {
+    [P in keyof T]?: PickOmitDeepSelection<T[P]>;
+}) : boolean;
+export type PickDeepSelection<T> = PickOmitDeepSelection<T>;
+export type OmitDeepSelection<T> = PickOmitDeepSelection<T>;
+export type PickDeep<T, S extends PickDeepSelection<T>> = T extends Record<any> ? Simplify<{
+    [P in keyof S as S[P] extends (true | Record<any>) ? P : never]: S[P] extends true ? T[Extract<P, keyof T>] : T[Extract<P, keyof T>] extends (infer U)[] ? S[P] extends PickDeepSelection<U> ? PickDeep<U, S[P]>[] : never : S[P] extends Record<any> ? S[P] extends PickDeepSelection<T[Extract<P, keyof T>]> ? PickDeep<T[Extract<P, keyof T>], S[P]> : never : never;
+}> : T;
+export type OmitDeep<T, S extends OmitDeepSelection<T>> = T extends Record<any> ? Simplify<{
+    [P in keyof T as true extends S[Extract<P, keyof S>] ? never : P]: [
+        S[Extract<P, keyof S>]
+    ] extends ([false] | [never]) ? T[P] : S[Extract<P, keyof S>] extends Record<any> ? T[P] extends (infer U)[] ? S[Extract<P, keyof S>] extends OmitDeepSelection<U> ? OmitDeep<U, S[Extract<P, keyof S>]>[] : never : S[Extract<P, keyof S>] extends OmitDeepSelection<T[P]> ? OmitDeep<T[P], S[Extract<P, keyof S>]> : never : never;
+}> : T;
+export type AnyFunction = Function;
 export {};

package/utils/async-iterable-helpers/to-async-iterator.js

@@ -21,12 +21,12 @@ export function iteratorToAsyncIterator(iterator) {
             return iterator.next(...args);
         }
     };
-    if (isDefined(iterator.return)) { // eslint-disable-line @typescript-eslint/unbound-method
+    if (isDefined(iterator.return)) {
         asyncIterator.return = async function _return(value) {
             return iterator.return(await value);
         };
     }
-    if (isDefined(iterator.throw)) { // eslint-disable-line @typescript-eslint/unbound-method
+    if (isDefined(iterator.throw)) {
         asyncIterator.throw = async function _throw(error) {
             return iterator.throw(error);
         };

package/utils/async-iterator-iterable-iterator.js

@@ -10,17 +10,17 @@ export class AsyncIteratorIterableIterator {
         return this.iterator.next(...args);
     }
     async return(value) {
-        assertDefined(this.iterator.return, 'underlying iterator has no return function defined'); // eslint-disable-line @typescript-eslint/unbound-method
+        assertDefined(this.iterator.return, 'underlying iterator has no return function defined');
         return this.iterator.return(value);
     }
     async throw(error) {
-        assertDefined(this.iterator.throw, 'underlying iterator has no throw function defined'); // eslint-disable-line @typescript-eslint/unbound-method
+        assertDefined(this.iterator.throw, 'underlying iterator has no throw function defined');
         return this.iterator.throw(error);
     }
     async *[Symbol.asyncIterator]() {
         let finished = false;
         try {
-            while (true) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+            while (true) {
                 const result = await this.iterator.next();
                 if (result.done == true) {
                     finished = true;

package/utils/base64.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-bitwise */
+/* eslint-disable @typescript-eslint/no-magic-numbers, no-bitwise */
 import { supportsBuffer } from '../supports.js';
 import { toUint8Array } from './binary.js';
 import { isArrayBuffer, isDefined } from './type-guards.js';

package/utils/cryptography.d.ts

@@ -32,34 +32,34 @@ export interface DigestResult extends CryptionResult {
 export interface SignResult extends CryptionResult {
 }
 /**
- * encrypt data
+ * Encrypt data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to encrypt. Encodes string to utf8
  */
 export declare function encrypt(algorithm: CryptionAlgorithm, key: CryptoKey, data: BinaryData | string): CryptionResult;
 /**
- * decrypt data
+ * Decrypt data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to decrypt
  */
 export declare function decrypt(algorithm: CryptionAlgorithm, key: CryptoKey, bytes: BinaryData): DecryptionResult;
 /**
- * hashes data
+ * Hashes data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param data data to encrypt. Encodes string to utf8
  */
 export declare function digest(algorithm: HashAlgorithmIdentifier, data: BinaryData | string): DigestResult;
 /**
- * signs data
+ * Signs data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to sign
  */
 export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: BinaryData | string): SignResult;
 /**
- * verifies data
+ * Verifies data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param signature signature
@@ -67,14 +67,14 @@ export declare function sign(algorithm: SignAlgorithm, key: CryptoKey, data: Bin
  */
 export declare function verify(algorithm: SignAlgorithm, key: CryptoKey, signature: BinaryData | string, data: BinaryData | string): Promise<boolean>;
 /**
- * imports a HMAC CryptoKey
+ * Imports a HMAC CryptoKey
  * @param algorithm hash algorithm
  * @param key JWK or binary key
  * @param extractable whether the key can be used for exportKey
  */
 export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
 /**
- * imports a CryptoKey for symmetric encryption
+ * Imports a CryptoKey for symmetric encryption
  * @param algorithm symmetric algorithm
  * @param length key length
  * @param key JWK or binary key
@@ -82,39 +82,39 @@ export declare function importHmacKey(algorithm: HashAlgorithmIdentifier, key: K
  */
 export declare function importSymmetricKey(algorithm: SymmetricAlgorithm, length: 128 | 192 | 256, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
 /**
- * imports an ECDSA CryptoKey
+ * Imports an ECDSA CryptoKey
  * @param curve ECDSA curve
  * @param key JWK or DER encoded key
  * @param extractable whether the key can be used for exportKey
  */
 export declare function importEcdsaKey(curve: EcdsaCurve, key: Key | string, extractable?: boolean): Promise<CryptoKey>;
 /**
- * import a pbkdf2 CryptoKey
+ * Import a pbkdf2 CryptoKey
  * @param key binary key
  * @param extractable whether the key can be used for exportKey
  */
 export declare function importPbkdf2Key(key: BinaryData | string, extractable?: boolean): Promise<CryptoKey>;
 /**
- * generates a new ECDSA CryptoKeyPair
+ * Generates a new ECDSA CryptoKeyPair
  * @param curve ECDSA cruve to use
  * @param extractable whether the key can be used for exportKey
  * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
  */
 export declare function generateEcdsaKey(curve: EcdsaCurve, extractable?: boolean, usages?: TypedExtract<KeyUsage, 'sign' | 'verify'>[]): Promise<CryptoKeyPair>;
 /**
- * generates a pbkdf2 CryptoKey
+ * Generates a pbkdf2 CryptoKey
  * @param extractable whether the key can be used for exportKey
  */
 export declare function generatePbkdf2Key(extractable?: boolean): Promise<CryptoKey>;
 /**
- * derive byte array from key
+ * Derive byte array from key
  * @param length length in bytes
  * @param algorithm algorithm to derive with
  * @param baseKey key to derive from
  */
 export declare function deriveBytes(algorithm: DeriveAlgorithm, baseKey: CryptoKey, length: number): Promise<Uint8Array>;
 /**
- * derive multiply byte arrays from key
+ * Derive multiply byte arrays from key
  * @param algorithm algorithm to derive with
  * @param baseKey key to derive from
  * @param length length of each Uint8Array in bytes, if single number is provided, it is used for every array

package/utils/cryptography.js

@@ -6,7 +6,7 @@ import { isArray, isDefined, isString } from './type-guards.js';
 import { zBase32Encode } from './z-base32.js';
 const subtle = globalThis.crypto.subtle;
 /**
- * encrypt data
+ * Encrypt data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to encrypt. Encodes string to utf8
@@ -23,7 +23,7 @@ export function encrypt(algorithm, key, data) {
     };
 }
 /**
- * decrypt data
+ * Decrypt data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to decrypt
@@ -40,7 +40,7 @@ export function decrypt(algorithm, key, bytes) {
     };
 }
 /**
- * hashes data
+ * Hashes data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param data data to encrypt. Encodes string to utf8
  */
@@ -57,7 +57,7 @@ export function digest(algorithm, data) {
     return result;
 }
 /**
- * signs data
+ * Signs data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param data data to sign
@@ -75,7 +75,7 @@ export function sign(algorithm, key, data) {
     return result;
 }
 /**
- * verifies data
+ * Verifies data
  * @param algorithm algorithm as supported by Web Crypto API
  * @param key key
  * @param signature signature
@@ -87,7 +87,7 @@ export async function verify(algorithm, key, signature, data) {
     return subtle.verify(algorithm, key, signatureBytes, dataBytes);
 }
 /**
- * imports a HMAC CryptoKey
+ * Imports a HMAC CryptoKey
  * @param algorithm hash algorithm
  * @param key JWK or binary key
  * @param extractable whether the key can be used for exportKey
@@ -100,7 +100,7 @@ export async function importHmacKey(algorithm, key, extractable = false) {
     return subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
 }
 /**
- * imports a CryptoKey for symmetric encryption
+ * Imports a CryptoKey for symmetric encryption
  * @param algorithm symmetric algorithm
  * @param length key length
  * @param key JWK or binary key
@@ -114,7 +114,7 @@ export async function importSymmetricKey(algorithm, length, key, extractable = f
     return subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
 }
 /**
- * imports an ECDSA CryptoKey
+ * Imports an ECDSA CryptoKey
  * @param curve ECDSA curve
  * @param key JWK or DER encoded key
  * @param extractable whether the key can be used for exportKey
@@ -127,7 +127,7 @@ export async function importEcdsaKey(curve, key, extractable = false) {
     return subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
 }
 /**
- * import a pbkdf2 CryptoKey
+ * Import a pbkdf2 CryptoKey
  * @param key binary key
  * @param extractable whether the key can be used for exportKey
  */
@@ -136,7 +136,7 @@ export async function importPbkdf2Key(key, extractable = false) {
     return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
 }
 /**
- * generates a new ECDSA CryptoKeyPair
+ * Generates a new ECDSA CryptoKeyPair
  * @param curve ECDSA cruve to use
  * @param extractable whether the key can be used for exportKey
  * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
@@ -145,7 +145,7 @@ export async function generateEcdsaKey(curve, extractable = false, usages = ['si
     return subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
 }
 /**
- * generates a pbkdf2 CryptoKey
+ * Generates a pbkdf2 CryptoKey
  * @param extractable whether the key can be used for exportKey
  */
 export async function generatePbkdf2Key(extractable = false) {
@@ -153,7 +153,7 @@ export async function generatePbkdf2Key(extractable = false) {
     return importPbkdf2Key(key, extractable);
 }
 /**
- * derive byte array from key
+ * Derive byte array from key
  * @param length length in bytes
  * @param algorithm algorithm to derive with
  * @param baseKey key to derive from

package/utils/date-time.js

@@ -100,7 +100,7 @@ export function dateTimeToTime(dateTime) {
     if (interval.isValid) {
         return interval.count('milliseconds');
     }
-    throw new Error('Invalid DateTime.');
+    throw new Error(`Invalid DateTime: ${interval.invalidExplanation}`);
 }
 export function numericDateTimeToDateTime({ date, time }, zone) {
     return numericDateToDateTime(date, undefined, { zone }).set({ millisecond: time });

package/utils/encoding.d.ts

@@ -1,35 +1,35 @@
 import type { BinaryData } from '../types.js';
 /**
- * encodes text to utf8
+ * Encodes text to utf8
  * @param text text to encode
  * @returns utf8 encoded text
  */
 export declare function encodeUtf8(text: string): Uint8Array;
 /**
- * encodes text stream to utf8 bytes stream
+ * Encodes text stream to utf8 bytes stream
  */
 export declare function encodeUtf8Stream(): TransformStream<string, Uint8Array>;
 /**
- * decodes buffer to string
+ * Decodes buffer to string
  * @param buffer buffer to decode
  * @param encoding encoding, defaults to utf8
  * @returns decoded string
  */
 export declare function decodeText(buffer: BinaryData, encoding?: string): string;
 /**
- * transforms binary stream to string stream
+ * Transforms binary stream to string stream
  * @param encoding encoding, defaults to utf8
  * @returns stream of decoded string
  */
 export declare function decodeTextStream(encoding?: string): TransformStream<BinaryData, string>;
 /**
- * encodes buffer to hex
+ * Encodes buffer to hex
  * @param buffer buffer to encode
  * @returns hex encoded string
  */
 export declare function encodeHex(buffer: BinaryData): string;
 /**
- * decodes hex string to buffer
+ * Decodes hex string to buffer
  * @param hex hex string to decode
  * @returns decoded buffer
  */

package/utils/encoding.js

@@ -5,7 +5,7 @@ import { isUndefined } from './type-guards.js';
 const byteToHex = createArray(2 ** 8, (i) => i).map((value) => value.toString(16).padStart(2, '0'));
 const hexToByte = new Map(byteToHex.map((hex, value) => [hex, value]));
 /**
- * encodes text to utf8
+ * Encodes text to utf8
  * @param text text to encode
  * @returns utf8 encoded text
  */
@@ -14,13 +14,13 @@ export function encodeUtf8(text) {
     return encoder.encode(text);
 }
 /**
- * encodes text stream to utf8 bytes stream
+ * Encodes text stream to utf8 bytes stream
  */
 export function encodeUtf8Stream() {
     return new TextEncoderStream();
 }
 /**
- * decodes buffer to string
+ * Decodes buffer to string
  * @param buffer buffer to decode
  * @param encoding encoding, defaults to utf8
  * @returns decoded string
@@ -30,7 +30,7 @@ export function decodeText(buffer, encoding) {
     return decoder.decode(buffer);
 }
 /**
- * transforms binary stream to string stream
+ * Transforms binary stream to string stream
  * @param encoding encoding, defaults to utf8
  * @returns stream of decoded string
  */
@@ -38,7 +38,7 @@ export function decodeTextStream(encoding) {
     return new TextDecoderStream(encoding, { fatal: true });
 }
 /**
- * encodes buffer to hex
+ * Encodes buffer to hex
  * @param buffer buffer to encode
  * @returns hex encoded string
  */
@@ -52,7 +52,7 @@ export function encodeHex(buffer) {
     return result;
 }
 /**
- * decodes hex string to buffer
+ * Decodes hex string to buffer
  * @param hex hex string to decode
  * @returns decoded buffer
  */

package/utils/enum.js

@@ -2,9 +2,15 @@ import { randomItem } from './array/array.js';
 import { memoizeSingle } from './function/memoize.js';
 import { objectEntries } from './object/object.js';
 import { isNumber } from './type-guards.js';
-const memoizedEnumEntries = memoizeSingle(_enumEntries, { weak: true });
-const memoizedEnumKeys = memoizeSingle(_enumKeys, { weak: true });
-const memoizedEnumValues = memoizeSingle(_enumValues, { weak: true });
+const memoizedEnumEntries = memoizeSingle((enumeration) => objectEntries(enumeration).filter((entry) => Number.isNaN(Number(entry[0]))), { weak: true });
+const memoizedEnumKeys = memoizeSingle((enumeration) => {
+    const entries = enumEntries(enumeration);
+    return entries.map((entry) => entry[0]);
+}, { weak: true });
+const memoizedEnumValues = memoizeSingle((enumeration) => {
+    const entries = enumEntries(enumeration);
+    return entries.map((entry) => entry[1]);
+}, { weak: true });
 export function enumValueName(enumeration, value) {
     return isNumber(value) ? enumeration[value]?.toString() ?? value.toString() : value;
 }
@@ -20,15 +26,3 @@ export function enumValues(enumeration) {
 export function randomEnumValue(enumeration) {
     return randomItem(enumValues(enumeration));
 }
-function _enumEntries(enumeration) {
-    return objectEntries(enumeration)
-        .filter((entry) => Number.isNaN(Number(entry[0])));
-}
-function _enumKeys(enumeration) {
-    const entries = enumEntries(enumeration);
-    return entries.map((entry) => entry[0]);
-}
-function _enumValues(enumeration) {
-    const entries = enumEntries(enumeration);
-    return entries.map((entry) => entry[1]);
-}

package/utils/equals.js

@@ -47,7 +47,7 @@ export function equals(a, b, options = {}, visitedNodes = new Set()) {
             return (options.deep == true)
                 ? a.toString() == b.toString()
                 : false;
-        case 'object':
+        case 'object': {
             if (isNull(a) || isNull(b)) { // hasn't passed equals check at top, so one must be a true object
                 return false;
             }
@@ -71,13 +71,14 @@ export function equals(a, b, options = {}, visitedNodes = new Set()) {
             if (Equals.symbol in b) {
                 return b[Equals.symbol](a);
             }
-            if ((aPrototype != Object.prototype) && isNotNull(aPrototype)) { // checking a is enough, because b must have equal prototype (checked above)
+            if ((aPrototype != Object.prototype) && isNotNull(aPrototype)) { // Checking a is enough, because b must have equal prototype (checked above)
                 throw new Error('Equals only supports literal objects, arrays, primitives and Equals interface implementations.');
             }
             if (options.deep == false) {
                 return false;
             }
             return objectEquals(a, b, options, visitedNodes);
+        }
         default:
             return a === b;
     }

package/utils/format-error.d.ts

@@ -1,24 +1,24 @@
 import type { UndefinableJson } from '../types.js';
 export type FormatErrorOptions = {
     /**
-     * include error name in message
+     * Include error name in message
      */
     includeName?: boolean;
     /**
-     * include all error properties beside name and message
+     * Include all error properties beside name and message
      */
     includeRest?: boolean | 'if-no-extra-info';
     /**
-     * include extraInfo from errors implementing {@link ErrorExtraInfo}
+     * Include extraInfo from errors implementing {@link ErrorExtraInfo}
      */
     includeExtraInfo?: boolean;
     /**
-     * include stack trace
+     * Include stack trace
      */
     includeStack?: boolean;
 };
 export interface ErrorExtraInfo {
-    /** format extra data (without message and stack) as JSON */
+    /** Format extra data (without message and stack) as JSON */
     getExtraInfo(): UndefinableJson | undefined;
 }
 export declare function formatError(error: any, options?: FormatErrorOptions): string;