@bleedingdev/modern-js-utils 3.2.0-ultramodern.0

package/dist/compiled/semver/internals/identifiers.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Compares two identifiers, must be numeric strings or truthy/falsy values.
+ *
+ * Sorts in ascending order when passed to `Array.sort()`.
+ */
+export function compareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;
+
+/**
+ * The reverse of compareIdentifiers.
+ *
+ * Sorts in descending order when passed to `Array.sort()`.
+ */
+export function rcompareIdentifiers(a: string | null | undefined, b: string | null | undefined): 1 | 0 | -1;

package/dist/compiled/semver/license

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/dist/compiled/semver/package.json

@@ -0,0 +1 @@
+{"name":"semver","author":"GitHub Inc.","version":"7.6.0","license":"ISC"}

package/dist/compiled/semver/ranges/gtr.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return true if version is greater than all the versions possible in the range.
+ */
+declare function gtr(
+    version: string | SemVer,
+    range: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+
+export = gtr;

package/dist/compiled/semver/ranges/intersects.d.ts

@@ -0,0 +1,13 @@
+import Range = require('../classes/range');
+import semver = require('../index');
+
+/**
+ * Return true if any of the ranges comparators intersect
+ */
+declare function intersects(
+    range1: string | Range,
+    range2: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+
+export = intersects;

package/dist/compiled/semver/ranges/ltr.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return true if version is less than all the versions possible in the range.
+ */
+declare function ltr(
+    version: string | SemVer,
+    range: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+
+export = ltr;

package/dist/compiled/semver/ranges/max-satisfying.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the highest version in the list that satisfies the range, or null if none of them do.
+ */
+declare function maxSatisfying<T extends string | SemVer>(
+    versions: ReadonlyArray<T>,
+    range: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): T | null;
+
+export = maxSatisfying;

package/dist/compiled/semver/ranges/min-satisfying.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the lowest version in the list that satisfies the range, or null if none of them do.
+ */
+declare function minSatisfying<T extends string | SemVer>(
+    versions: ReadonlyArray<T>,
+    range: string | Range,
+    optionsOrLoose?: boolean | semver.Options,
+): T | null;
+
+export = minSatisfying;

package/dist/compiled/semver/ranges/min-version.d.ts

@@ -0,0 +1,10 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return the lowest version that can possibly match the given range.
+ */
+declare function minVersion(range: string | Range, optionsOrLoose?: boolean | semver.Options): SemVer | null;
+
+export = minVersion;

package/dist/compiled/semver/ranges/outside.d.ts

@@ -0,0 +1,15 @@
+import Range = require('../classes/range');
+import SemVer = require('../classes/semver');
+import semver = require('../index');
+
+/**
+ * Return true if the version is outside the bounds of the range in either the high or low direction.
+ * The hilo argument must be either the string '>' or '<'. (This is the function called by gtr and ltr.)
+ */
+declare function outside(
+    version: string | SemVer,
+    range: string | Range,
+    hilo: '>' | '<',
+    optionsOrLoose?: boolean | semver.Options,
+): boolean;
+export = outside;

package/dist/compiled/semver/ranges/simplify.d.ts

@@ -0,0 +1,14 @@
+import Range = require('../classes/range');
+import semver = require('../index');
+
+/**
+ * Return a "simplified" range that matches the same items in `versions` list as the range specified.
+ * Note that it does *not* guarantee that it would match the same versions in all cases,
+ * only for the set of versions provided.
+ * This is useful when generating ranges by joining together multiple versions with `||` programmatically,
+ * to provide the user with something a bit more ergonomic.
+ * If the provided range is shorter in string-length than the generated range, then that is returned.
+ */
+declare function simplify(ranges: string[], range: string | Range, options?: semver.Options): string | Range;
+
+export = simplify;

package/dist/compiled/semver/ranges/subset.d.ts

@@ -0,0 +1,13 @@
+import Range = require('../classes/range');
+import semver = require('../index');
+
+/**
+ * Return true if the subRange range is entirely contained by the superRange range.
+ */
+declare function subset(
+    sub: string | Range,
+    dom: string | Range,
+    options?: semver.Options,
+): boolean;
+
+export = subset;

package/dist/compiled/semver/ranges/to-comparators.d.ts

@@ -0,0 +1,9 @@
+import Range = require('../classes/range');
+import semver = require('../index');
+
+/**
+ * Mostly just for testing and legacy API reasons
+ */
+declare function toComparators(range: string | Range, optionsOrLoose?: boolean | semver.Options): string[][];
+
+export = toComparators;

package/dist/compiled/semver/ranges/valid.d.ts

@@ -0,0 +1,12 @@
+import Range = require('../classes/range');
+import semver = require('../index');
+
+/**
+ * Return the valid range or null if it's not valid
+ */
+declare function validRange(
+    range: string | Range | null | undefined,
+    optionsOrLoose?: boolean | semver.Options,
+): string | null;
+
+export = validRange;

package/dist/compiled/signale/index.d.ts

@@ -0,0 +1,162 @@
+// Type definitions for signale 1.4
+// Project: https://github.com/klaussinani/signale
+// Definitions by: Resi Respati <https://github.com/resir014>
+//                 Joydip Roy <https://github.com/rjoydip>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.7
+
+/// <reference types="node" />
+
+declare namespace signale {
+    type DefaultMethods =
+        | 'await'
+        | 'complete'
+        | 'error'
+        | 'debug'
+        | 'fatal'
+        | 'fav'
+        | 'info'
+        | 'note'
+        | 'pause'
+        | 'pending'
+        | 'star'
+        | 'start'
+        | 'success'
+        | 'warn'
+        | 'watch'
+        | 'log';
+
+    interface CommandType {
+        /** The icon corresponding to the logger. */
+        badge: string;
+        /**
+         * The color of the label, can be any of the foreground colors supported by
+         * [chalk](https://github.com/chalk/chalk#colors).
+         */
+        color: string;
+        /** The label used to identify the type of the logger. */
+        label: string;
+        logLevel?: string | undefined;
+        stream?: NodeJS.WriteStream | NodeJS.WriteStream[] | undefined;
+    }
+
+    interface SignaleConfig {
+        /** Display the scope name of the logger. */
+        displayScope?: boolean | undefined;
+        /** Display the badge of the logger. */
+        displayBadge?: boolean | undefined;
+        /** Display the current local date in `YYYY-MM-DD` format. */
+        displayDate?: boolean | undefined;
+        /** Display the name of the file that the logger is reporting from. */
+        displayFilename?: boolean | undefined;
+        /** Display the label of the logger. */
+        displayLabel?: boolean | undefined;
+        /** Display the current local time in `HH:MM:SS` format. */
+        displayTimestamp?: boolean | undefined;
+        /** Underline the logger label. */
+        underlineLabel?: boolean | undefined;
+        /** Underline the logger message. */
+        underlineMessage?: boolean | undefined;
+        underlinePrefix?: boolean | undefined;
+        underlineSuffix?: boolean | undefined;
+        uppercaseLabel?: boolean | undefined;
+    }
+
+    interface SignaleOptions<TTypes extends string = DefaultMethods> {
+        /** Sets the configuration of an instance overriding any existing global or local configuration. */
+        config?: SignaleConfig | undefined;
+        disabled?: boolean | undefined;
+        /**
+         * Name of the scope.
+         */
+        scope?: string | undefined;
+        /**
+         * Holds the configuration of the custom and default loggers.
+         */
+        types?: Partial<Record<TTypes, CommandType>> | undefined;
+        interactive?: boolean | undefined;
+        logLevel?: string | undefined;
+        timers?: Map<string, Date> | undefined;
+        /**
+         * Destination to which the data is written, can be any valid
+         * [Writable stream](https://nodejs.org/api/stream.html#stream_writable_streams).
+         */
+        stream?: NodeJS.WriteStream | NodeJS.WriteStream[] | undefined;
+        secrets?: Array<string | number> | undefined;
+    }
+
+    interface SignaleConstructor {
+        new <TTypes extends string = DefaultMethods>(options?: SignaleOptions<TTypes>): Signale<TTypes>;
+    }
+
+    interface SignaleBase<TTypes extends string = DefaultMethods> {
+        /**
+         * Sets the configuration of an instance overriding any existing global or local configuration.
+         *
+         * @param configObj Can hold any of the documented options.
+         */
+        config(configObj: SignaleConfig): Signale<TTypes>;
+        /**
+         * Defines the scope name of the logger.
+         *
+         * @param name Can be one or more comma delimited strings.
+         */
+        scope(...name: string[]): Signale<TTypes>;
+        /** Clears the scope name of the logger. */
+        unscope(): void;
+        /**
+         * Sets a timers and accepts an optional label. If none provided the timer will receive a unique label automatically.
+         *
+         * @param label Label corresponding to the timer. Each timer must have its own unique label.
+         * @returns a string corresponding to the timer label.
+         */
+        time(label?: string): string;
+        /**
+         * Deactivates the timer to which the given label corresponds. If no label
+         * is provided the most recent timer, that was created without providing a
+         * label, will be deactivated.
+         *
+         * @param label Label corresponding to the timer, each timer has its own unique label.
+         * @param span Total running time.
+         */
+        timeEnd(label?: string, span?: number): { label: string; span?: number | undefined };
+        /**
+         * Disables the logging functionality of all loggers belonging to a specific instance.
+         */
+        disable(): void;
+        /**
+         * Enables the logging functionality of all loggers belonging to a specific instance.
+         */
+        enable(): void;
+        /**
+         * Checks whether the logging functionality of a specific instance is enabled.
+         *
+         * @returns a boolean that describes whether or not the logger is enabled.
+         */
+        isEnabled(): boolean;
+        /**
+         * Adds new secrets/sensitive-information to the targeted Signale instance.
+         *
+         * @param secrets Array holding the secrets/sensitive-information to be filtered out.
+         */
+        addSecrets(secrets: string[] | number[]): void;
+        /**
+         * Removes all secrets/sensitive-information from the targeted Signale instance.
+         */
+        clearSecrets(): void;
+    }
+
+    type LoggerFunc = (message?: any, ...optionalArgs: any[]) => void;
+    type Signale<TTypes extends string = DefaultMethods> = SignaleBase<TTypes> &
+        Record<TTypes, LoggerFunc> &
+        Record<DefaultMethods, LoggerFunc>;
+}
+
+declare const signale: signale.Signale<signale.DefaultMethods> & {
+    Signale: signale.SignaleConstructor;
+    SignaleConfig: signale.SignaleConfig;
+    SignaleOptions: signale.SignaleOptions;
+    DefaultMethods: signale.DefaultMethods;
+};
+
+export = signale;