clientnode 4.0.1441 → 4.0.1442

package/dist/Lock.d.ts

@@ -0,0 +1,39 @@
+import type { LockCallbackFunction, Mapping } from './type';
+/**
+ * Represents the lock state.
+ * @property locks - Mapping of lock descriptions to their corresponding
+ * callbacks.
+ */
+export declare class Lock<Type = string | undefined> {
+    lock?: Array<LockCallbackFunction<Type>>;
+    locks: Mapping<Array<LockCallbackFunction<Type>>>;
+    /**
+     * Initializes locks.
+     * @param locks - Mapping of a lock description to callbacks for calling
+     * when given lock should be released.
+     */
+    constructor(locks?: Mapping<Array<LockCallbackFunction<Type>>>);
+    /**
+     * Calling this method introduces a starting point for a critical area with
+     * potential race conditions. The area will be bind to given description
+     * string. So don't use same names for different areas.
+     * @param description - A short string describing the critical areas
+     * properties.
+     * @param callback - A procedure which should only be executed if the
+     * interpreter isn't in the given critical area. The lock description
+     * string will be given to the callback function.
+     * @param autoRelease - Release the lock after execution of given callback.
+     * @returns Returns a promise which will be resolved after releasing lock.
+     */
+    acquire(description?: string, callback?: LockCallbackFunction<Type>, autoRelease?: boolean): Promise<Type>;
+    /**
+     * Calling this method causes the given critical area to be finished and
+     * all functions given to "acquire()" will be executed in right order.
+     * @param description - A short string describing the critical areas
+     * properties.
+     * @returns Returns the return (maybe promise resolved) value of the
+     * callback given to the "acquire" method.
+     */
+    release(description?: string): Promise<Type | undefined>;
+}
+export default Lock;

package/dist/Logger.d.ts

@@ -0,0 +1,102 @@
+import type { LoggerOptions, Mapping } from './type';
+export declare const LEVELS: readonly ["error", "critical", "warn", "info", "debug"];
+export declare const LEVELS_COLOR: ("\u001B[0;34m" | "\u001B[32m" | "\u001B[35m" | "\u001B[31m" | "\u001B[33m")[];
+export type Level = typeof LEVELS[number];
+/**
+ * This plugin provides such interface logic like generic controller logic for
+ * integrating plugins into $, mutual exclusion for dependent gui elements,
+ * logging additional string, array or function handling. A set of helper
+ * functions to parse  option objects dom trees or handle events is also
+ * provided.
+ * @property level - Logging level.
+ * @property name - Logger description.
+ */
+export declare class Logger {
+    static defaultLevel: Level;
+    static defaultName: string;
+    static selfClass: typeof Logger;
+    static instances: Mapping<Logger>;
+    static runtimeVersion: number;
+    /**
+     * Configures all logger instances.
+     * @param options - Options to set.
+     */
+    static configureAllInstances(options?: Partial<LoggerOptions>): void;
+    level: Level;
+    name: string;
+    /**
+     * Initializes logger.
+     * @param options - Options to set.
+     */
+    constructor(options?: Partial<LoggerOptions>);
+    /**
+     * Configures logger.
+     * @param options - Options to set.
+     * @param options.name - Description of the logger instance.
+     * @param options.level - Logging level to configure.
+     */
+    configure({ name, level }: Partial<LoggerOptions>): void;
+    /**
+     * Shows the given object's representation in the browsers console if
+     * possible or in a standalone alert-window as fallback.
+     * @param object - Any object to print.
+     * @param force - If set to "true" given input will be shown independently
+     * of current logging configuration or interpreter's console
+     * implementation.
+     * @param avoidAnnotation - If set to "true" given input has no module or
+     * log level specific annotations.
+     * @param level - Description of log messages importance.
+     * @param additionalArguments - Additional values to print.
+     */
+    log(object: unknown, force?: boolean, avoidAnnotation?: boolean, level?: Level, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Wrapper method for the native console method usually provided by
+     * interpreter.
+     * @param object - Any object to print.
+     * @param additionalArguments - Additional arguments are used for string
+     * formatting.
+     */
+    info(object: unknown, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Wrapper method for the native console method usually provided by
+     * interpreter.
+     * @param object - Any object to print.
+     * @param additionalArguments - Additional arguments are used for string
+     * formatting.
+     */
+    debug(object: unknown, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Wrapper method for the native console method usually provided by
+     * interpreter.
+     * @param object - Any object to print.
+     * @param additionalArguments - Additional arguments are used for string
+     * formatting.
+     */
+    error(object: unknown, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Wrapper method for the native console method usually provided by
+     * interpreter.
+     * @param object - Any object to print.
+     * @param additionalArguments - Additional arguments are used for string
+     * formatting.
+     */
+    critical(object: unknown, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Wrapper method for the native console method usually provided by
+     * interpreter.
+     * @param object - Any object to print.
+     * @param additionalArguments - Additional arguments are used for string
+     * formatting.
+     */
+    warn(object: unknown, ...additionalArguments: Array<unknown>): void;
+    /**
+     * Dumps a given object in a human-readable format.
+     * @param object - Any object to show.
+     * @param level - Number of levels to dig into given object recursively.
+     * @param currentLevel - Maximal number of recursive function calls to
+     * represent given object.
+     * @returns Returns the serialized version of given object.
+     */
+    static show(object: unknown, level?: number, currentLevel?: number): string;
+}
+export default Logger;

package/dist/Semaphore.d.ts

@@ -0,0 +1,29 @@
+import type { AnyFunction } from './type';
+/**
+ * Represents the semaphore state.
+ * @property queue - List of waiting resource requests.
+ * @property numberOfFreeResources - Number free allowed concurrent resource
+ * uses.
+ * @property numberOfResources - Number of allowed concurrent resource uses.
+ */
+export declare class Semaphore {
+    queue: Array<AnyFunction>;
+    numberOfResources: number;
+    numberOfFreeResources: number;
+    /**
+     * Initializes number of resources.
+     * @param numberOfResources - Number of resources to manage.
+     */
+    constructor(numberOfResources?: number);
+    /**
+     * Acquires a new resource and runs given callback if available.
+     * @returns A promise which will be resolved if requested resource is
+     * available.
+     */
+    acquire(): Promise<number>;
+    /**
+     * Releases a resource and runs a waiting resolver if there exists some.
+     */
+    release(): void;
+}
+export default Semaphore;

package/dist/array.d.ts

@@ -0,0 +1,150 @@
+import type { Mapping, Page, PaginateOptions } from './type';
+/**
+ * Summarizes given property of given item list.
+ * @param data - Array of objects with given property name.
+ * @param propertyName - Property name to summarize.
+ * @param defaultValue - Value to return if property values doesn't match.
+ * @returns Aggregated value.
+ */
+export declare const aggregatePropertyIfEqual: <T = unknown>(data: Array<Mapping<unknown>>, propertyName: string, defaultValue?: T) => T;
+/**
+ * Deletes every item witch has only empty attributes for given property names.
+ * If given property names are empty each attribute will be considered. The
+ * empty string, "null" and "undefined" will be interpreted as empty.
+ * @param data - Data to filter.
+ * @param propertyNames - Properties to consider.
+ * @returns Given data without empty items.
+ */
+export declare const deleteEmptyItems: <T extends Mapping<unknown> = Mapping<unknown>>(data: Array<T>, propertyNames?: Array<string | symbol>) => Array<T>;
+/**
+ * Extracts all properties from all items which occur in given property names.
+ * @param data - Data where each item should be sliced.
+ * @param propertyNames - Property names to extract.
+ * @returns Data with sliced items.
+ */
+export declare const extract: <T = Mapping<unknown>>(data: unknown, propertyNames: Array<string>) => Array<T>;
+/**
+ * Extracts all values which matches given regular expression.
+ * @param data - Data to filter.
+ * @param regularExpression - Pattern to match for.
+ * @returns Filtered data.
+ */
+export declare const extractIfMatches: (data: unknown, regularExpression: string | RegExp) => Array<string>;
+/**
+ * Filters given data if given property is set or not.
+ * @param data - Data to filter.
+ * @param propertyName - Property name to check for existence.
+ * @returns Given data without the items which doesn't have specified property.
+ */
+export declare const extractIfPropertyExists: <T extends Mapping<unknown> = Mapping<unknown>>(data: unknown, propertyName: string) => Array<T>;
+/**
+ * Extract given data where specified property value matches given patterns.
+ * @param data - Data to filter.
+ * @param propertyPattern - Mapping of property names to pattern.
+ * @returns Filtered data.
+ */
+export declare const extractIfPropertyMatches: <T = unknown>(data: unknown, propertyPattern: Mapping<RegExp | string>) => Array<T>;
+/**
+ * Determines all objects which exists in "first" and in "second".
+ * Object key which will be compared are given by "keys". If an empty array is
+ * given each key will be compared. If an object is given corresponding initial
+ * data key will be mapped to referenced new data key.
+ * @param first - Referenced data to check for.
+ * @param second - Data to check for existence.
+ * @param keys - Keys to define equality.
+ * @param strict - The strict parameter indicates whether "null" and
+ * "undefined" should be interpreted as equal (takes only effect if given keys
+ * aren't empty).
+ * @returns Data which does exit in given initial data.
+ */
+export declare const intersect: <T = unknown>(first: unknown, second: unknown, keys?: Array<string> | Mapping<number | string>, strict?: boolean) => Array<T>;
+/**
+ * Converts given object into an array.
+ * @param object - Target to convert.
+ * @returns Generated array.
+ */
+export declare const makeArray: <T = unknown>(object: unknown) => Array<T>;
+/**
+ * Creates a list of items within given range.
+ * @param range - Array of lower and upper bounds. If only one value is given
+ * lower bound will be assumed to be zero. Both integers have to be positive
+ * and will be contained in the resulting array. If more than two numbers are
+ * provided given range will be returned.
+ * @param step - Space between two consecutive values.
+ * @param ignoreLastStep - Removes last step.
+ * @returns Produced array of integers.
+ */
+export declare const makeRange: (range: number | Array<number> | [number] | [number, number], step?: number, ignoreLastStep?: boolean) => Array<number>;
+/**
+ * Merge the contents of two arrays together into the first array.
+ * @param target - Target array.
+ * @param source - Source array.
+ * @returns Target array with merged given source one.
+ */
+export declare const merge: <T = unknown>(target: Array<T>, source: Array<T>) => Array<T>;
+/**
+ * Generates a list if pagination symbols to render a pagination from.
+ * @param options - Configure bounds and current page of pagination to
+ * determine.
+ * @param options.boundaryCount - Indicates where to start pagination within
+ * given total range.
+ * @param options.disabled - Indicates whether to disable all items.
+ * @param options.hideNextButton - Indicates whether to show a jump to next
+ * item.
+ * @param options.hidePrevButton - Indicates whether to show a jump to previous
+ * item.
+ * @param options.page - Indicates current visible page.
+ * @param options.pageSize - Number of items per page.
+ * @param options.showFirstButton - Indicates whether to show a jump to first
+ * item.
+ * @param options.showLastButton - Indicates whether to show a jump to last
+ * item.
+ * @param options.siblingCount - Number of sibling page symbols next to current
+ * page symbol.
+ * @param options.total - Number of all items to paginate.
+ * @returns A list of pagination symbols.
+ */
+export declare const paginate: (options?: Partial<PaginateOptions>) => Array<Page>;
+/**
+ * Generates all permutations of given iterable.
+ * @param data - Array like object.
+ * @returns Array of permuted arrays.
+ */
+export declare const permute: <T = unknown>(data: Array<T>) => Array<Array<T>>;
+/**
+ * Generates all lengths permutations of given iterable.
+ * @param data - Array like object.
+ * @param minimalSubsetLength - Defines how long the minimal subset length
+ * should be.
+ * @returns Array of permuted arrays.
+ */
+export declare const permuteLength: <T = unknown>(data: Array<T>, minimalSubsetLength?: number) => Array<Array<T>>;
+/**
+ * Sums up given property of given item list.
+ * @param data - The objects with specified property to sum up.
+ * @param propertyName - Property name to sum up its value.
+ * @returns The aggregated value.
+ */
+export declare const sumUpProperty: (data: unknown, propertyName: string) => number;
+/**
+ * Removes given target on given list.
+ * @param list - Array to splice.
+ * @param target - Target to remove from given list.
+ * @param strict - Indicates whether to fire an exception if given target
+ * doesn't exist given list.
+ * @returns Item with the appended target.
+ */
+export declare const removeArrayItem: <T = unknown>(list: Array<T>, target: T, strict?: boolean) => Array<T>;
+/**
+ * Sorts given object of dependencies in a topological order.
+ * @param items - Items to sort.
+ * @returns Sorted array of given items respecting their dependencies.
+ */
+export declare const sortTopological: (items: Mapping<Array<string> | string>) => Array<string>;
+/**
+ * Makes all values in given iterable unique by removing duplicates (The first
+ * occurrences will be left).
+ * @param data - Array like object.
+ * @returns Sliced version of given object.
+ */
+export declare const unique: <T = unknown>(data: Array<T>) => Array<T>;

package/dist/cli.d.ts

@@ -0,0 +1,31 @@
+export declare const CLI_COLOR: {
+    readonly black: "\u001B[30m";
+    readonly blink: "\u001B[5m";
+    readonly blue: "\u001B[0;34m";
+    readonly bold: "\u001B[1m";
+    readonly cyan: "\u001B[36m";
+    readonly darkGray: "\u001B[0;90m";
+    readonly default: "\u001B[0m";
+    readonly dim: "\u001B[2m";
+    readonly green: "\u001B[32m";
+    readonly invert: "\u001B[7m";
+    readonly invisible: "\u001B[8m";
+    readonly lightBlue: "\u001B[0;94m";
+    readonly lightCyan: "\u001B[0;96m";
+    readonly lightGray: "\u001B[0;37m";
+    readonly lightGreen: "\u001B[0;92m";
+    readonly lightMagenta: "\u001B[0;95m";
+    readonly lightRed: "\u001B[0;91m";
+    readonly lightYellow: "\u001B[0;93m";
+    readonly magenta: "\u001B[35m";
+    readonly nodim: "\u001B[22m";
+    readonly noblink: "\u001B[25m";
+    readonly nobold: "\u001B[21m";
+    readonly noinvert: "\u001B[27m";
+    readonly noinvisible: "\u001B[28m";
+    readonly nounderline: "\u001B[24m";
+    readonly red: "\u001B[31m";
+    readonly underline: "\u001B[4m";
+    readonly white: "\u001B[37m";
+    readonly yellow: "\u001B[33m";
+};

package/dist/constants.d.ts

@@ -0,0 +1,99 @@
+import type { Encoding, FirstParameter } from './type';
+export { Lock } from './Lock';
+export { Semaphore } from './Semaphore';
+export declare const DEFAULT_ENCODING: Encoding;
+export declare const CLOSE_EVENT_NAMES: readonly ["close", "exit", "SIGINT", "SIGTERM", "SIGQUIT", "uncaughtException"];
+export declare const CONSOLE_METHODS: readonly ["debug", "error", "info", "log", "warn"];
+export declare const VALUE_COPY_SYMBOL: unique symbol;
+export declare const IGNORE_NULL_AND_UNDEFINED_SYMBOL: unique symbol;
+export declare const ABBREVIATIONS: Array<string>;
+export declare const ANIMATION_END_EVENT_NAMES = "animationend webkitAnimationEnd oAnimationEnd MSAnimationEnd";
+export declare const CLASS_TO_TYPE_MAPPING: {
+    readonly '[object Array]': "array";
+    readonly '[object Boolean]': "boolean";
+    readonly '[object Date]': "date";
+    readonly '[object Error]': "error";
+    readonly '[object Function]': "function";
+    readonly '[object Map]': "map";
+    readonly '[object Number]': "number";
+    readonly '[object Object]': "object";
+    readonly '[object RegExp]': "regexp";
+    readonly '[object Set]': "set";
+    readonly '[object String]': "string";
+};
+export declare const KEY_CODES: {
+    readonly BACKSPACE: 8;
+    readonly SPACE: 32;
+    readonly TAB: 9;
+    readonly DELETE: 46;
+    readonly ENTER: 13;
+    readonly COMMA: 188;
+    readonly PERIOD: 190;
+    readonly END: 35;
+    readonly ESCAPE: 27;
+    readonly F1: 112;
+    readonly F2: 113;
+    readonly F3: 114;
+    readonly F4: 115;
+    readonly F5: 116;
+    readonly F6: 117;
+    readonly F7: 118;
+    readonly F8: 119;
+    readonly F9: 120;
+    readonly F10: 121;
+    readonly F11: 122;
+    readonly F12: 123;
+    readonly HOME: 36;
+    readonly NUMPAD_ADD: 107;
+    readonly NUMPAD_SUBTRACT: 109;
+    readonly NUMPAD_DECIMAL: 110;
+    readonly NUMPAD_DIVIDE: 111;
+    readonly NUMPAD_ENTER: 108;
+    readonly NUMPAD_MULTIPLY: 106;
+    readonly PAGE_UP: 33;
+    readonly PAGE_DOWN: 34;
+    readonly UP: 38;
+    readonly DOWN: 40;
+    readonly LEFT: 37;
+    readonly RIGHT: 39;
+};
+export declare const KEYBOARD_CODES: {
+    readonly BACKSPACE: "Backspace";
+    readonly SPACE: "Space";
+    readonly TAB: "Tab";
+    readonly DELETE: "Delete";
+    readonly ENTER: "Enter";
+    readonly COMMA: "Comma";
+    readonly PERIOD: "Period";
+    readonly END: "End";
+    readonly ESCAPE: "Escape";
+    readonly F1: "F1";
+    readonly F2: "F2";
+    readonly F3: "F3";
+    readonly F4: "F4";
+    readonly F5: "F5";
+    readonly F6: "F6";
+    readonly F7: "F7";
+    readonly F8: "F8";
+    readonly F9: "F9";
+    readonly F10: "F10";
+    readonly F11: "F111";
+    readonly F12: "F12";
+    readonly HOME: "Home";
+    readonly NUMPAD_ADD: "NumpadAdd";
+    readonly NUMPAD_SUBTRACT: "NumpadSubtract";
+    readonly NUMPAD_DECIMAL: "NumpadDecimal";
+    readonly NUMPAD_DIVIDE: "NumpadDivide";
+    readonly NUMPAD_ENTER: "NumpadEnter";
+    readonly NUMPAD_MULTIPLY: "NumpadMultiply";
+    readonly PAGE_UP: "PageUp";
+    readonly PAGE_DOWN: "PageUp";
+    readonly UP: "ArrowUp";
+    readonly DOWN: "ArrowDown";
+    readonly LEFT: "ArrowLeft";
+    readonly RIGHT: "ArrowUp";
+};
+export declare const LOCALES: Array<string>;
+export declare const PLAIN_OBJECT_PROTOTYPES: Array<FirstParameter<typeof Object.getPrototypeOf>>;
+export declare const SPECIAL_REGEX_SEQUENCES: Array<string>;
+export declare const TRANSITION_END_EVENT_NAMES = "transitionend webkitTransitionEnd oTransitionEnd MSTransitionEnd";

package/dist/context.d.ts

@@ -0,0 +1,8 @@
+import type { AnyFunction } from './type';
+export declare let globalContext: Partial<typeof globalThis>;
+export declare const setGlobalContext: (context: typeof globalThis) => void;
+export declare const MAXIMAL_NUMBER_OF_ITERATIONS: {
+    value: number;
+};
+export declare const NOOP: AnyFunction;
+export declare const mockConsole: () => void;

package/dist/cookie.d.ts

@@ -0,0 +1,31 @@
+import type { CookieOptions } from './type';
+/**
+ * Deletes a cookie value by given name.
+ * @param name - Name to identify requested value.
+ */
+export declare const deleteCookie: (name: string) => void;
+/**
+ * Gets a cookie value by given name.
+ * @param name - Name to identify requested value.
+ * @returns Requested value.
+ */
+export declare const getCookie: (name: string) => string | null;
+/**
+ * Sets a cookie key-value-pair.
+ * @param name - Name to identify given value.
+ * @param value - Value to set.
+ * @param givenOptions - Cookie set options.
+ * @param givenOptions.domain - Domain to reference with given key-value-pair.
+ * @param givenOptions.httpOnly - Indicates if this cookie should be accessible
+ * from client or not.
+ * @param givenOptions.minimal - Set only minimum number of options.
+ * @param givenOptions.numberOfDaysUntilExpiration - Number of days until given
+ * key shouldn't be deleted.
+ * @param givenOptions.path - Path to reference with given key-value-pair.
+ * @param givenOptions.sameSite - Set same site policy to "Lax", "None" or
+ * "Strict".
+ * @param givenOptions.secure - Indicates if this cookie is only valid for
+ * "https" connections.
+ * @returns A boolean indicating whether cookie could be set or not.
+ */
+export declare const setCookie: (name: string, value: string, givenOptions?: Partial<CookieOptions>) => boolean;

package/dist/data-transfer.d.ts

@@ -0,0 +1,45 @@
+import type { CheckReachabilityOptions, RecursivePartial } from './type';
+/**
+ * Checks if given url response with given status code.
+ * @param url - Url to check reachability.
+ * @param givenOptions - Options to configure.
+ * @param givenOptions.wait - Boolean indicating if we should retry until a
+ * status code will be given.
+ * @param givenOptions.statusCodes - Status codes to check for.
+ * @param givenOptions.timeoutInSeconds - Delay after assuming given resource
+ * isn't available if no response is coming.
+ * @param givenOptions.pollIntervallInSeconds - Seconds between two tries to
+ * reach given url.
+ * @param givenOptions.options - Fetch options to use.
+ * @param givenOptions.expectedIntermediateStatusCodes - A list of expected but
+ * unwanted response codes. If detecting them waiting will continue until an
+ * expected (positive) code occurs or timeout is reached.
+ * @returns A promise which will be resolved if a request to given url has
+ * finished and resulting status code matches given expected status code.
+ * Otherwise, returned promise will be rejected.
+ */
+export declare const checkReachability: (url: string, givenOptions?: RecursivePartial<CheckReachabilityOptions>) => ReturnType<typeof fetch>;
+/**
+ * Checks if given url isn't reachable.
+ * @param url - Url to check reachability.
+ * @param givenOptions - Options to configure.
+ * @param givenOptions.wait - Boolean indicating if we should retry until a
+ * status code will be given.
+ * @param givenOptions.timeoutInSeconds - Delay after assuming given resource
+ * will stay available.
+ * @param givenOptions.pollIntervallInSeconds - Seconds between two tries to
+ * reach given url.
+ * @param givenOptions.statusCodes - Status codes to check for.
+ * @param givenOptions.options - Fetch options to use.
+ * @returns A promise which will be resolved if a request to given url couldn't
+ * be finished. Otherwise, returned promise will be rejected. If "wait" is set
+ * to "true" we will resolve to another promise still resolving when final
+ * timeout is reached or the endpoint is unreachable (after some tries).
+ */
+export declare const checkUnreachability: (url: string, givenOptions?: RecursivePartial<CheckReachabilityOptions>) => Promise<Error | null | Promise<Error | null>>;
+/**
+ * Preloads a given url via a temporary created image element.
+ * @param url - To image which should be downloaded.
+ * @returns A Promise indicating whether the image was loaded.
+ */
+export declare const cacheImage: (url: string) => Promise<void>;

package/dist/datetime.d.ts

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,82 @@
+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>;