clientnode 4.0.1435 → 4.0.1437

package/dist/datetime.d.ts

@@ -1,37 +0,0 @@
-import type { SecondParameter } from './type';
-export declare const DATE_TIME_PATTERN_CACHE: Array<RegExp>;
-/**
- * Formats given date or current via given format specification.
- * @param format - Format specification.
- * @param dateTime - Date time to format.
- * @param options - Additional configuration options for "Intl.DateTimeFormat".
- * @param locales - Locale or list of locales to use for formatting. First one
- * take precedence of latter ones.
- * @returns Formatted date time string.
- */
-export declare const dateTimeFormat: (format?: string, dateTime?: Date | number | string, options?: SecondParameter<typeof Intl.DateTimeFormat>, locales?: Array<string> | string) => string;
-/**
- * Interprets given content string as date time.
- * @param value - Date time string to interpret.
- * @param interpretAsUTC - Identifies if given date should be interpreted as
- * utc. If not set given strings will be interpreted as it is depended on
- * given format and number like string as utc.
- * @returns Interpret date time object.
- */
-export declare const interpretDateTime: (value: string, interpretAsUTC?: boolean | null) => Date | null;
-/**
- * Interprets a date object from given artefact.
- * @param value - To interpret.
- * @param interpretAsUTC - Identifies if given date should be interpreted as
- * utc. If not set given strings will be interpreted as it is dependent on
- * given format and numbers as utc.
- * @returns Interpreted date object or "null" if given value couldn't be
- * interpreted.
- */
-export declare const normalizeDateTime: (value?: string | null | number | Date, interpretAsUTC?: boolean | null) => Date | null;
-/**
- * Slice weekday from given date representation.
- * @param value - String to process.
- * @returns Sliced given string.
- */
-export declare const sliceWeekday: (value: string) => string;

package/dist/domNode.d.ts

@@ -1,82 +0,0 @@
-import type { GivenInterruptableScrollToOptions, KnownEventName } from './type';
-export declare const createDomNodes: <Type extends Node = Node>(html: string) => Type;
-export declare const fade: (domNode: HTMLElement, intervalInMilliseconds?: number, out?: boolean) => Promise<void> & {
-    clear: () => void;
-    resetStyles: () => void;
-};
-export declare const fadeIn: (domNode: HTMLElement, intervalInMilliseconds?: number) => Promise<void> & {
-    clear: () => void;
-    resetStyles: () => void;
-};
-export declare const fadeOut: (domNode: HTMLElement, intervalInMilliseconds?: number) => Promise<void> & {
-    clear: () => void;
-    resetStyles: () => void;
-};
-export declare const STOP_AUTO_SCROLLING: {
-    value: import("./type").AnyFunction;
-};
-export declare const MANUAL_SCROLL_EVENT_NAMES: Array<KnownEventName>;
-export declare const SCROLL_EVENT_NAMES: Array<KnownEventName>;
-/**
- * Smoothly scrolls both horizontally and vertically to a target DOM node.
- * Cancels instantly if the user interacts with the mouse, touch, or keys.
- * @param givenOptions - Configuration options.
- * @param givenOptions.targetDomNode - The DOM node you want to scroll to.
- * @param givenOptions.containerDomNode - The scrollable parent.
- * @param givenOptions.durationInMilliseconds - Animation duration in
- * milliseconds.
- * @param givenOptions.interruptOnManualScroll - Whether to stop the animation
- * if the user starts to scroll manually.
- * @param givenOptions.offset - Pixel offsets.
- * @param givenOptions.offset.top - Vertical offset in pixels.
- * @param givenOptions.offset.left - Horizontal offset in pixels.
- */
-export declare const interruptableScrollTo: (givenOptions?: GivenInterruptableScrollToOptions) => void;
-/**
- * Scrolls to the given DomNode's location or tio of the page.
- * @param targetDomNode - DomNode to scroll to. If not given, scrolls to the
- * top of the page.
- * @param behavior - Scroll behavior to use.
- */
-export declare const scrollTo: (targetDomNode?: Node | null, behavior?: ScrollToOptions["behavior"]) => void;
-export declare const getAll: (root: Node) => Node[];
-export declare const closest: (node: Node, selector: string, startWithParent?: boolean) => Element | null;
-export declare const getParents: (node: Node) => Array<Node>;
-export declare const getText: (root: Node, recursive?: boolean) => Array<string>;
-/**
- * Checks whether given html or text strings are equal.
- * @param first - First html, selector to dom node or text to compare.
- * @param second - Second html, selector to dom node or text to compare.
- * @param forceHTMLString - Indicates whether given contents are
- * interpreted as html string (otherwise automatic detection will be
- * triggered).
- * @returns Returns true if both dom representations are equivalent.
- */
-export declare const isEquivalent: (first: Node | string, second: Node | string, forceHTMLString?: boolean) => boolean;
-/**
- * Checks whether the given dom node is visible or takes space in the document
- * flow.
- * Elements with visibility: hidden or opacity: 0 are considered to be visible,
- * since they still consume space in the layout. During animations that hide an
- * element, the element is considered to be visible until the end of the
- * animation.
- * @param domNode - To inspect.
- * @returns A boolean indicating the visibility.
- */
-export declare const isHidden: (domNode: HTMLElement) => boolean;
-export declare const onDocumentReady: (callback?: () => void) => Promise<void>;
-/**
- * Replaces a given dom node with given nodes.
- * @param domNodeToReplace - Node to replace its children.
- * @param replacementDomNodes - Node or array of nodes to use as replacement.
- * @param skipEmptyTextNodes - Configures whether to trim text.
- */
-export declare const replace: (domNodeToReplace: HTMLElement, replacementDomNodes: Array<Node> | Node, skipEmptyTextNodes?: boolean) => void;
-export declare const wrap: (domNodes: Node | NodeListOf<Node>, wrapper: HTMLElement) => void;
-/**
- * Moves the content of a given dom node one level up and removes the given
- * node.
- * @param domNode - Node to unwrap.
- * @returns List of unwrapped nodes.
- */
-export declare const unwrap: (domNode: HTMLElement) => Array<ChildNode>;

package/dist/expression/evaluators.d.ts

@@ -1,55 +0,0 @@
-import type { Mapping, Options } from '../';
-import type { NormalizedSelector, Selector, ArrayContainsExpression, AndExpression, OrExpression, ConcatExpression, Expression, IfExpression, SwitchExpression, CaseExpression, UnaryOperation, Operation, Condition, BasicScopeType, RecursiveKeyOf, MappingExpression } from './type';
-export declare const SELECTOR_KEY_NAMES: Set<string>;
-export declare const NO_ITEM_FOUND_SYMBOL: unique symbol;
-export declare const DEFAULT_OPTIONS: {
-    skipMissingLevel: boolean;
-    contextReplacements: {};
-    delimiter: string;
-};
-export declare const normalizeSelector: <ScopeType extends BasicScopeType>(selector: Selector<ScopeType>, givenOptions?: Partial<Options<ScopeType> & {
-    scope: ScopeType;
-}>) => NormalizedSelector<ScopeType>;
-export declare const selectArrayItem: (data: Array<unknown>, keyOrIndex: number | string) => unknown;
-/**
- * Retrieves substructure in given object referenced by given selector
- * path.
- * @param selector - Selector path.
- * @param scope - Object to search in.
- * @param givenOptions - Object to configure evaluation.
- * @param givenOptions.contextReplacements - Configuration how to replace
- * "this" and "thisParent" keywords in selectors.
- * @param givenOptions.delimiter - Delimiter to delimit given selector
- * components.
- * @param givenOptions.skipMissingLevel - Indicates to skip missing level in
- * given path.
- * @returns Determined sub structure of given data or "undefined".
- */
-export declare const evaluateSelectorUntilLastObject: <ScopeType extends BasicScopeType>(selector: Selector<ScopeType>, scope?: ScopeType, givenOptions?: Partial<Options<ScopeType>>) => [ScopeType, RecursiveKeyOf];
-/**
- * Retrieves substructure in given object referenced by given selector
- * path.
- * @param selector - Selector path.
- * @param scope - Object to search in.
- * @param options - Options object to configure evaluation.
- * @param options.contextReplacements - Configuration how to replace "this"
- * and "thisParent" keywords in selectors.
- * @param options.delimiter - Delimiter to delimit given selector components.
- * @param options.skipMissingLevel - Indicates to skip missing level in given
- * path.
- * @returns Determined sub structure of given data or "undefined".
- */
-export declare const evaluateSelector: <Type, ScopeType extends BasicScopeType>(selector: Selector<ScopeType>, scope?: ScopeType, options?: Partial<Options<ScopeType>>) => Type;
-export declare const evaluateCondition: <ScopeType extends BasicScopeType>(condition: Condition, scope: ScopeType, options: Partial<Options<ScopeType>>) => boolean;
-export declare const evaluateUnaryOperation: <ScopeType extends BasicScopeType>(operation: UnaryOperation, scope: ScopeType, options: Partial<Options<ScopeType>>) => boolean;
-export declare const evaluateOperation: <ScopeType extends BasicScopeType>(operation: Operation, scope: ScopeType, options: Partial<Options<ScopeType>>) => number;
-export declare const evaluateOptionalThen: <Type, ScopeType extends BasicScopeType>(expression: IfExpression<Type> | CaseExpression<Type>, scope: ScopeType, options: Partial<Options<ScopeType>>) => Type;
-export declare const evaluateIf: <Type, ScopeType extends BasicScopeType>(expression: IfExpression<Type>, scope: ScopeType, options: Partial<Options<ScopeType>>) => Type;
-export declare const evaluateSwitch: <Type, ScopeType extends BasicScopeType>(expression: SwitchExpression<Type>, scope: ScopeType, options: Partial<Options<ScopeType>>) => Type;
-export declare const evaluateAnd: <ScopeType extends BasicScopeType>(expression: AndExpression, scope: ScopeType, options: Partial<Options<ScopeType>>) => boolean;
-export declare const evaluateOr: <ScopeType extends BasicScopeType>(expression: OrExpression, scope: ScopeType, options: Partial<Options<ScopeType>>) => boolean;
-export declare const evaluateConcat: <ScopeType extends BasicScopeType>(expression: ConcatExpression, scope: ScopeType, options: Partial<Options<ScopeType>>) => Array<unknown> | string;
-export declare const evaluateMapping: <ScopeType extends BasicScopeType>(expression: MappingExpression, scope: ScopeType, options: Partial<Options<ScopeType>>) => Array<Mapping<unknown>>;
-export declare const evaluateArrayContains: <ScopeType extends BasicScopeType>(expression: ArrayContainsExpression, scope: ScopeType, options: Partial<Options<ScopeType>>) => boolean;
-export declare function evaluateExpression<Type, ScopeType extends BasicScopeType>(expression: Expression<Type, ScopeType>, scope?: ScopeType, options?: Partial<Options<ScopeType>>): Type;
-export default evaluateExpression;

package/dist/expression/helper.d.ts

@@ -1,4 +0,0 @@
-import type { Mapping } from '../';
-import type { BasicScopeType } from './type';
-export declare const viewArrayAsScope: <Type extends Array<Mapping<unknown>>, ScopeType extends BasicScopeType>(data: Type, childrenPropertyNames: Array<string>, propertyReferenceKeys: Array<string>) => ScopeType;
-export declare const viewObjectAsScope: <Type extends Mapping<unknown>, ScopeType extends BasicScopeType = BasicScopeType>(data: Type, childrenPropertyNames?: string[], propertyReferenceKeys?: string[]) => ScopeType;

package/dist/expression/index.d.ts

@@ -1,7 +0,0 @@
-export * from './type';
-import evaluateExpressionFunction from './evaluators';
-export * from './evaluators';
-export * from './helper';
-export * from './indicator-functions';
-export declare const evaluateExpression: typeof evaluateExpressionFunction;
-export default evaluateExpression;

package/dist/expression/indicator-functions.d.ts

@@ -1,14 +0,0 @@
-import type { BasicScopeType, AndExpression, OrExpression, ConcatExpression, MappingExpression, Expression, IfExpression, SwitchExpression, Operation, UnaryOperation, Condition, SelectorExpression, ArrayContainsExpression } from './type';
-export declare const isSpecificExpression: (expression: Expression, indicatorKey: string, properties?: Array<string>) => boolean;
-export declare const isCondition: (expression: Expression) => expression is Condition;
-export declare const isAndExpression: (expression: Expression) => expression is AndExpression;
-export declare const isOrExpression: (expression: Expression) => expression is OrExpression;
-export declare const isConcatExpression: (expression: Expression) => expression is ConcatExpression;
-export declare const isMappingExpression: (expression: Expression) => expression is MappingExpression;
-export declare const isOperation: (expression: Expression) => expression is Operation;
-export declare const isUnaryOperation: (expression: Expression) => expression is UnaryOperation;
-export declare const isIfExpression: <Type>(expression: Expression<Type>) => expression is IfExpression<Type>;
-export declare const isSwitchExpression: <Type>(expression: Expression<Type>) => expression is SwitchExpression<Type>;
-export declare const isSelector: <Type, ScopeType extends BasicScopeType>(expression: Expression<Type, ScopeType>) => expression is SelectorExpression<ScopeType>;
-export declare const isArrayContainsExpression: <Type, ScopeType extends BasicScopeType>(expression: Expression<Type, ScopeType>) => expression is ArrayContainsExpression;
-export declare const isValue: <Type, ScopeType extends BasicScopeType>(expression: Expression<Type, ScopeType>) => expression is Type;

package/dist/expression/type.d.ts

@@ -1,70 +0,0 @@
-import type { Mapping } from '../';
-export type BasicScopeType = Array<unknown> | Mapping<unknown> | unknown;
-export type KeyPathOf = string;
-export type SimpleRecursiveKeyOf = number | string;
-export type RecursiveKeyOf = ((scope: unknown) => unknown) | SimpleRecursiveKeyOf;
-export type SelectorItem<Type extends BasicScopeType> = RecursiveKeyOf | Expression<RecursiveKeyOf | number, Type>;
-export type NormalizedSelector<Type extends BasicScopeType> = Array<SelectorItem<Type>>;
-export type Selector<Type extends BasicScopeType> = SelectorItem<Type> | NormalizedSelector<Type>;
-export type ContextReplacements<ScopeType extends BasicScopeType> = Mapping<Selector<ScopeType>>;
-export interface Options<ScopeType extends BasicScopeType> {
-    contextReplacements: ContextReplacements<ScopeType>;
-    delimiter: string;
-    skipMissingLevel: boolean;
-}
-export type Comparator = '==' | '!=' | '<' | '>' | '<=' | '>=';
-export type UnaryOperator = '!' | '!!';
-export type Operator = '+' | '-' | '*' | '**' | '/';
-export type Scope<Type = unknown> = Mapping<Type>;
-export interface Condition {
-    value1: Expression;
-    $comparator: Comparator;
-    value2: Expression;
-}
-export interface IfExpression<Type> {
-    $if: Expression<boolean>;
-    then?: Expression<Type>;
-    else?: Expression<Type>;
-}
-export interface SwitchExpression<Type> {
-    $switch: Expression;
-    caseExpressions: Array<CaseExpression<Type>>;
-    default?: Expression<Type>;
-}
-export interface CaseExpression<Type> {
-    $case: Expression;
-    then?: Expression<Type>;
-}
-export interface ArrayContainsExpression {
-    $arrayContains: {
-        target?: Expression;
-        key?: Expression<string>;
-        value: Expression<string | number | boolean>;
-    };
-}
-export interface AndExpression {
-    $and: Array<Expression<boolean>>;
-}
-export interface OrExpression {
-    $or: Array<Expression<boolean>>;
-}
-export interface ConcatExpression {
-    $concat: Array<Expression<Array<unknown> | string>>;
-}
-export interface MappingExpression {
-    $mapping: Expression<Mapping>;
-    data: Expression<Mapping<Mapping<unknown>> | Array<Mapping<unknown>>>;
-}
-export interface UnaryOperation {
-    operand: Expression;
-    $operator: UnaryOperator;
-}
-export interface Operation {
-    operand1: Expression<number>;
-    $operator: Operator;
-    operand2: Expression<number>;
-}
-export interface SelectorExpression<ScopeType extends BasicScopeType> {
-    $select: Selector<ScopeType>;
-}
-export type Expression<Type = unknown, ScopeType extends BasicScopeType = BasicScopeType> = Condition | AndExpression | OrExpression | ConcatExpression | MappingExpression | UnaryOperation | Operation | IfExpression<Type> | SwitchExpression<Type> | ArrayContainsExpression | SelectorExpression<ScopeType> | Type;

package/dist/filesystem.d.ts

@@ -1,143 +0,0 @@
-import type { ObjectEncodingOptions } from 'node:fs';
-import type { AnyFunction, Encoding, File, FileTraverseResult } from './type';
-export declare const imports: {
-    fs: null | typeof import('fs');
-    fsPromises: null | typeof import('fs/promises');
-    path: null | typeof import('path');
-};
-export declare const importsPromise: Promise<[typeof import("fs") | null, typeof import("fs/promises") | null, typeof import("node:path") | null]>;
-/**
- * Copies given source directory via path to given target directory location
- * with same target name as source file has or copy to given complete target
- * directory path.
- * @param sourcePath - Path to directory to copy.
- * @param targetPath - Target directory or complete directory location to copy
- * in.
- * @param contents - Indicates whether we only want to copy content of source
- * path without recreating the sourcefile itself on target location.
- * @param callback - Function to invoke for each traversed file.
- * @param readOptions - Options to use for reading source file.
- * @param writeOptions - Options to use for writing to target file.
- * @returns Promise holding the determined target directory path.
- */
-export declare const copyDirectoryRecursive: (sourcePath: string, targetPath: string, contents?: boolean, callback?: AnyFunction, readOptions?: {
-    encoding: null;
-    flag: string;
-}, writeOptions?: {
-    encoding: Encoding;
-    flag: string;
-    mode: number;
-}) => Promise<string>;
-/**
- * Copies given source directory via path to given target directory location
- * with same target name as source file has or copy to given complete target
- * directory path.
- * @param sourcePath - Path to directory to copy.
- * @param targetPath - Target directory or complete directory location to copy
- * in.
- * @param contents - Indicates whether we only want to copy content of source
- * path without recreating the sourcefile itself on target location.
- * @param callback - Function to invoke for each traversed file.
- * @param readOptions - Options to use for reading source file.
- * @param writeOptions - Options to use for writing to target file.
- * @returns Determined target directory path.
- */
-export declare const copyDirectoryRecursiveSync: (sourcePath: string, targetPath: string, contents?: boolean, callback?: AnyFunction, readOptions?: {
-    encoding: null;
-    flag: string;
-}, writeOptions?: {
-    encoding: Encoding;
-    flag: string;
-    mode: number;
-}) => string;
-/**
- * Copies given source file via path to given target directory location with
- * same target name as source file has or copy to given complete target file
- * path.
- * @param sourcePath - Path to file to copy.
- * @param targetPath - Target directory or complete file location to copy to.
- * @param readOptions - Options to use for reading source file.
- * @param writeOptions - Options to use for writing to target file.
- * @returns Determined target file path.
- */
-export declare const copyFile: (sourcePath: string, targetPath: string, readOptions?: {
-    encoding: null;
-    flag: string;
-}, writeOptions?: {
-    encoding: Encoding;
-    flag: string;
-    mode: number;
-}) => Promise<string>;
-/**
- * Copies given source file via path to given target directory location with
- * same target name as source file has or copy to given complete target file
- * path.
- * @param sourcePath - Path to file to copy.
- * @param targetPath - Target directory or complete file location to copy to.
- * @param readOptions - Options to use for reading source file.
- * @param writeOptions - Options to use for writing to target file.
- * @returns Determined target file path.
- */
-export declare const copyFileSync: (sourcePath: string, targetPath: string, readOptions?: {
-    encoding: null;
-    flag: string;
-}, writeOptions?: {
-    encoding: Encoding;
-    flag: string;
-    mode: number;
-}) => string;
-/**
- * Checks if given path points to a valid directory.
- * @param filePath - Path to directory.
- * @returns A promise holding a boolean which indicates directory existence.
- */
-export declare const isDirectory: (filePath: string) => Promise<boolean>;
-/**
- * Checks if given path points to a valid directory.
- * @param filePath - Path to directory.
- * @returns A boolean which indicates directory existence.
- */
-export declare const isDirectorySync: (filePath: string) => boolean;
-/**
- * Checks if given path points to a valid file.
- * @param filePath - Path to directory.
- * @returns A promise holding a boolean which indicates directory existence.
- */
-export declare const isFile: (filePath: string) => Promise<boolean>;
-/**
- * Checks if given path points to a valid file.
- * @param filePath - Path to file.
- * @returns A boolean which indicates file existence.
- */
-export declare const isFileSync: (filePath: string) => boolean;
-/**
- * Iterates through given directory structure recursively and calls given
- * callback for each found file. Callback gets file path and corresponding stat
- * object as argument.
- * @param directoryPath - Path to directory structure to traverse.
- * @param callback - Function to invoke for each traversed file and potentially
- * manipulate further traversing in alphabetical sorted order.
- * If it returns "null" or a promise resolving to "null", no further files
- * will be traversed afterward.
- * If it handles a directory and returns "false" or a promise resolving to
- * "false" no traversing into that directory will occur.
- * @param options - Options to use for nested "readdir" calls.
- * @returns A promise holding the determined files.
- */
-export declare const walkDirectoryRecursively: (directoryPath: string, callback?: null | ((file: File) => FileTraverseResult), options?: (Encoding | (ObjectEncodingOptions & {
-    withFileTypes?: false;
-    recursive?: boolean;
-}))) => Promise<Array<File>>;
-/**
- * Iterates through given directory structure recursively and calls given
- * callback for each found file. Callback gets file path and corresponding
- * stats object as argument.
- * @param directoryPath - Path to directory structure to traverse.
- * @param callback - Function to invoke for each traversed file.
- * @param options - Options to use for nested "readdir" calls.
- * @returns Determined list if all files.
- */
-export declare const walkDirectoryRecursivelySync: (directoryPath: string, callback?: AnyFunction | null, options?: (Encoding | (ObjectEncodingOptions & {
-    withFileTypes?: false;
-    recursive?: boolean;
-}))) => Array<File>;

package/dist/function.d.ts

@@ -1,20 +0,0 @@
-import type { AnyFunction } from './type';
-/**
- * Determines all parameter names from given callable (function or class,
- * ...).
- * @param callable - Function or function code to inspect.
- * @returns List of parameter names.
- */
-export declare const getParameterNames: (callable: AnyFunction | string) => Array<string>;
-/**
- * Implements the identity function.
- * @param value - A value to return.
- * @returns Returns the given value.
- */
-export declare const identity: <T>(value: T) => T;
-/**
- * Inverted filter helper to inverse each given filter.
- * @param filter - A function that filters an array.
- * @returns The inverted filter.
- */
-export declare const invertArrayFilter: <T, D = Array<unknown>>(filter: T) => T;

package/dist/index.d.ts

@@ -1,23 +0,0 @@
-export * from './array';
-export * from './domNode';
-export * from './cli';
-export * from './constants';
-export * from './context';
-export * from './cookie';
-export * from './data-transfer';
-export * from './datetime';
-export * from './expression/index';
-export * from './filesystem';
-export * from './function';
-export * from './indicators';
-export * from './Lock';
-export * from './number';
-export * from './object';
-export * from './process';
-export * from './module';
-export * from './scope';
-export * from './Semaphore';
-export * from './string';
-export * from './Logger';
-export * from './type';
-export * from './utility';

package/dist/indicators.d.ts

@@ -1,68 +0,0 @@
-import type { AnyFunction, Mapping, PlainObject, ProxyType } from './type';
-/**
- * Determines whether its argument represents a JavaScript number.
- * @param value - Value to analyze.
- * @returns A boolean value indicating whether given object is numeric
- * like.
- */
-export declare const isNumeric: (value: unknown) => value is number;
-/**
- * Determine whether the argument is a window.
- * @param value - Value to check for.
- * @returns Boolean value indicating the result.
- */
-export declare const isWindow: (value: unknown) => value is Window;
-/**
- * Checks if given object is similar to an array and can be handled like an
- * array.
- * @param object - Object to check behavior for.
- * @returns A boolean value indicating whether given object is array like.
- */
-export declare const isArrayLike: (object: unknown) => boolean;
-/**
- * Checks whether one of the given pattern matches given string.
- * @param target - Target to check in pattern for.
- * @param pattern - List of pattern to check for.
- * @returns Value "true" if given object is matches by at leas one of the
- * given pattern and "false" otherwise.
- */
-export declare const isAnyMatching: (target: string, pattern: Array<RegExp | string>) => boolean;
-/**
- * Checks whether given object is a native object but not null.
- * @param value - Value to check.
- * @returns Value "true" if given object is a plain javaScript object and
- * "false" otherwise.
- */
-export declare const isObject: (value: unknown) => value is Mapping<unknown>;
-/**
- * Checks whether given object is a plain native object.
- * @param value - Value to check.
- * @returns Value "true" if given object is a plain javaScript object and
- * "false" otherwise.
- */
-export declare const isPlainObject: (value: unknown) => value is PlainObject;
-/**
- * Checks whether given object is a set.
- * @param value - Value to check.
- * @returns Value "true" if given object is a set and "false" otherwise.
- */
-export declare const isSet: (value: unknown) => value is Set<unknown>;
-/**
- * Checks whether given object is a map.
- * @param value - Value to check.
- * @returns Value "true" if given object is a map and "false" otherwise.
- */
-export declare const isMap: (value: unknown) => value is Map<unknown, unknown>;
-/**
- * Checks whether given object is a proxy.
- * @param value - Value to check.
- * @returns Value "true" if given object is a proxy and "false" otherwise.
- */
-export declare const isProxy: (value: unknown) => value is ProxyType;
-/**
- * Checks whether given object is a function.
- * @param value - Value to check.
- * @returns Value "true" if given object is a function and "false"
- * otherwise.
- */
-export declare const isFunction: (value: unknown) => value is AnyFunction;

package/dist/module.d.ts

@@ -1,8 +0,0 @@
-import type { FirstParameter } from './type';
-export declare const determineGlobalContext: () => Partial<typeof globalThis>;
-export declare const currentRequire: null | typeof require;
-export declare const optionalRequire: <T = unknown>(id: string) => null | T;
-export declare const clearRequireCache: (cache?: typeof require.cache) => typeof require.cache;
-export declare const isolatedRequire: (path: FirstParameter<typeof require>, requireFunction?: typeof require) => ReturnType<typeof require>;
-export declare const isImportSyntaxSupported: () => boolean;
-export declare const optionalImport: <T = unknown>(id: string, options?: {}) => Promise<null | T>;

package/dist/number.d.ts

@@ -1,35 +0,0 @@
-/**
- * Determines corresponding utc timestamp for given date object.
- * @param value - Date to convert.
- * @param inMilliseconds - Indicates whether given number should be in
- * seconds (default) or milliseconds.
- * @returns Determined numerous value.
- */
-export declare const getUTCTimestamp: (value?: Date | null | number | string, inMilliseconds?: boolean) => number;
-/**
- * Checks if given object is java scripts native "Number.NaN" object.
- * @param value - Value to check.
- * @returns Returns whether given value is not a number or not.
- */
-export declare const isNotANumber: (value: unknown) => boolean;
-/**
- * Rounds a given number accurate to given number of digits.
- * @param number - The number to round.
- * @param digits - The number of digits after comma.
- * @returns Returns the rounded number.
- */
-export declare const round: (number: number, digits?: number) => number;
-/**
- * Rounds a given number up accurate to given number of digits.
- * @param number - The number to round.
- * @param digits - The number of digits after comma.
- * @returns Returns the rounded number.
- */
-export declare const ceil: (number: number, digits?: number) => number;
-/**
- * Rounds a given number down accurate to given number of digits.
- * @param number - The number to round.
- * @param digits - The number of digits after comma.
- * @returns Returns the rounded number.
- */
-export declare const floor: (number: number, digits?: number) => number;