@lerna-lite/core 1.3.0 → 1.4.0

package/dist/otplease.js

@@ -1,109 +1,109 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getOneTimePassword = exports.otplease = void 0;
-const prompt_1 = require("./prompt");
-// basic single-entry semaphore
-const semaphore = {
-    wait() {
-        return new Promise((resolve) => {
-            if (!this._promise) {
-                // not waiting, block other callers until 'release' is called.
-                this._promise = new Promise((release) => {
-                    this._resolve = release;
-                });
-                resolve(undefined);
-            }
-            else {
-                // wait for 'release' to be called and try to lock the semaphore again.
-                resolve(this._promise.then(() => this.wait()));
-            }
-        });
-    },
-    release() {
-        const resolve = this._resolve;
-        // istanbul ignore else
-        if (resolve) {
-            this._resolve = undefined;
-            this._promise = undefined;
-            // notify waiters that the semaphore has been released.
-            resolve();
-        }
-    },
-};
-/**
- * Attempt to execute Promise callback, prompting for OTP if necessary.
- * @template {Record<string, unknown>} T
- * @param {(opts: T) => Promise<unknown>} fn
- * @param {T} _opts The options to be passed to `fn`
- * @param {OneTimePasswordCache} otpCache
- */
-function otplease(fn, _opts, otpCache) {
-    // always prefer explicit config (if present) to cache
-    const opts = { ...otpCache, ..._opts };
-    return attempt(fn, opts, otpCache);
-}
-exports.otplease = otplease;
-/** @returns {Promise<unknown>} */
-function attempt(fn, opts, otpCache) {
-    return new Promise((resolve) => {
-        resolve(fn(opts));
-    }).catch((err) => {
-        if (err.code !== 'EOTP' && !(err.code === 'E401' && /one-time pass/.test(err.body))) {
-            throw err;
-        }
-        else if (!process.stdin.isTTY || !process.stdout.isTTY) {
-            throw err;
-        }
-        else {
-            // check the cache in case a concurrent caller has already updated the otp.
-            if (!isNullOrUndefined(otpCache) && !isNullOrUndefined(otpCache.otp) && otpCache.otp !== opts.otp) {
-                return attempt(fn, { ...opts, ...otpCache }, otpCache);
-            }
-            // only allow one getOneTimePassword attempt at a time to reuse the value
-            // from the preceeding prompt
-            return semaphore.wait().then(() => {
-                // check the cache again in case a previous waiter already updated it.
-                if (!isNullOrUndefined(otpCache) && !isNullOrUndefined(otpCache.otp) && otpCache.otp !== opts.otp) {
-                    semaphore.release();
-                    return attempt(fn, { ...opts, ...otpCache }, otpCache);
-                }
-                return getOneTimePassword()
-                    .then((otp) => {
-                    // update the otp and release the lock so that waiting
-                    // callers can see the updated otp.
-                    if (!isNullOrUndefined(otpCache)) {
-                        // eslint-disable-next-line no-param-reassign
-                        otpCache.otp = otp;
-                    }
-                    semaphore.release();
-                    return otp;
-                }, (promptError) => {
-                    // release the lock and reject the promise.
-                    semaphore.release();
-                    return Promise.reject(promptError);
-                })
-                    .then((otp) => {
-                    return fn({ ...opts, otp });
-                });
-            });
-        }
-    });
-}
-/**
- * Prompt user for one-time password.
- * @returns {Promise<string>}
- */
-function getOneTimePassword(message = 'This operation requires a one-time password:') {
-    // Logic taken from npm internals: https://github.com/npm/cli/blob/4f801d8a476f7ca52b0f182bf4e17a80db12b4e2/lib/utils/read-user-info.js#L21-L35
-    return (0, prompt_1.promptTextInput)(message, {
-        filter: (otp) => otp.replace(/\s+/g, ''),
-        validate: (otp) => (otp && /^[\d ]+$|^[A-Fa-f0-9]{64,64}$/.test(otp)) ||
-            'Must be a valid one-time-password. ' +
-                'See https://docs.npmjs.com/getting-started/using-two-factor-authentication',
-    });
-}
-exports.getOneTimePassword = getOneTimePassword;
-function isNullOrUndefined(val) {
-    return val === null || val === undefined;
-}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOneTimePassword = exports.otplease = void 0;
+const prompt_1 = require("./prompt");
+// basic single-entry semaphore
+const semaphore = {
+    wait() {
+        return new Promise((resolve) => {
+            if (!this._promise) {
+                // not waiting, block other callers until 'release' is called.
+                this._promise = new Promise((release) => {
+                    this._resolve = release;
+                });
+                resolve(undefined);
+            }
+            else {
+                // wait for 'release' to be called and try to lock the semaphore again.
+                resolve(this._promise.then(() => this.wait()));
+            }
+        });
+    },
+    release() {
+        const resolve = this._resolve;
+        // istanbul ignore else
+        if (resolve) {
+            this._resolve = undefined;
+            this._promise = undefined;
+            // notify waiters that the semaphore has been released.
+            resolve();
+        }
+    },
+};
+/**
+ * Attempt to execute Promise callback, prompting for OTP if necessary.
+ * @template {Record<string, unknown>} T
+ * @param {(opts: T) => Promise<unknown>} fn
+ * @param {T} _opts The options to be passed to `fn`
+ * @param {OneTimePasswordCache} otpCache
+ */
+function otplease(fn, _opts, otpCache) {
+    // always prefer explicit config (if present) to cache
+    const opts = { ...otpCache, ..._opts };
+    return attempt(fn, opts, otpCache);
+}
+exports.otplease = otplease;
+/** @returns {Promise<unknown>} */
+function attempt(fn, opts, otpCache) {
+    return new Promise((resolve) => {
+        resolve(fn(opts));
+    }).catch((err) => {
+        if (err.code !== 'EOTP' && !(err.code === 'E401' && /one-time pass/.test(err.body))) {
+            throw err;
+        }
+        else if (!process.stdin.isTTY || !process.stdout.isTTY) {
+            throw err;
+        }
+        else {
+            // check the cache in case a concurrent caller has already updated the otp.
+            if (!isNullOrUndefined(otpCache) && !isNullOrUndefined(otpCache.otp) && otpCache.otp !== opts.otp) {
+                return attempt(fn, { ...opts, ...otpCache }, otpCache);
+            }
+            // only allow one getOneTimePassword attempt at a time to reuse the value
+            // from the preceeding prompt
+            return semaphore.wait().then(() => {
+                // check the cache again in case a previous waiter already updated it.
+                if (!isNullOrUndefined(otpCache) && !isNullOrUndefined(otpCache.otp) && otpCache.otp !== opts.otp) {
+                    semaphore.release();
+                    return attempt(fn, { ...opts, ...otpCache }, otpCache);
+                }
+                return getOneTimePassword()
+                    .then((otp) => {
+                    // update the otp and release the lock so that waiting
+                    // callers can see the updated otp.
+                    if (!isNullOrUndefined(otpCache)) {
+                        // eslint-disable-next-line no-param-reassign
+                        otpCache.otp = otp;
+                    }
+                    semaphore.release();
+                    return otp;
+                }, (promptError) => {
+                    // release the lock and reject the promise.
+                    semaphore.release();
+                    return Promise.reject(promptError);
+                })
+                    .then((otp) => {
+                    return fn({ ...opts, otp });
+                });
+            });
+        }
+    });
+}
+/**
+ * Prompt user for one-time password.
+ * @returns {Promise<string>}
+ */
+function getOneTimePassword(message = 'This operation requires a one-time password:') {
+    // Logic taken from npm internals: https://github.com/npm/cli/blob/4f801d8a476f7ca52b0f182bf4e17a80db12b4e2/lib/utils/read-user-info.js#L21-L35
+    return (0, prompt_1.promptTextInput)(message, {
+        filter: (otp) => otp.replace(/\s+/g, ''),
+        validate: (otp) => (otp && /^[\d ]+$|^[A-Fa-f0-9]{64,64}$/.test(otp)) ||
+            'Must be a valid one-time-password. ' +
+                'See https://docs.npmjs.com/getting-started/using-two-factor-authentication',
+    });
+}
+exports.getOneTimePassword = getOneTimePassword;
+function isNullOrUndefined(val) {
+    return val === null || val === undefined;
+}
 //# sourceMappingURL=otplease.js.map

package/dist/package-graph/index.d.ts

@@ -1,2 +1,2 @@
-export * from './package-graph';
-export * from './lib';
+export * from './package-graph';
+export * from './lib';

package/dist/package-graph/index.js

@@ -1,19 +1,19 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./package-graph"), exports);
-__exportStar(require("./lib"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./package-graph"), exports);
+__exportStar(require("./lib"), exports);
 //# sourceMappingURL=index.js.map

package/dist/package-graph/lib/cyclic-package-graph-node.d.ts

@@ -1,42 +1,42 @@
-import { PackageGraphNode } from '../../package-graph';
-/**
- * Represents a cyclic collection of nodes in a PackageGraph.
- * It is meant to be used as a black box, where the only exposed
- * information are the connections to the other nodes of the graph.
- * It can contain either `PackageGraphNode`s or other `CyclicPackageGraphNode`s.
- *
- * @extends {Map<string, import('..').PackageGraphNode | CyclicPackageGraphNode>}
- */
-export declare class CyclicPackageGraphNode extends Map<string, PackageGraphNode | CyclicPackageGraphNode> {
-    name: string;
-    localDependencies: Map<string, any>;
-    localDependents: Map<string, any>;
-    constructor();
-    get isCycle(): boolean;
-    /**
-     * @returns {string} A representation of a cycle, like like `A -> B -> C -> A`.
-     */
-    toString(): string;
-    /**
-     * Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
-     */
-    flatten(): PackageGraphNode[];
-    /**
-     * Checks if a given node is contained in this cycle (or in a nested one)
-     *
-     * @param {string} name The name of the package to search in this cycle
-     * @returns {boolean}
-     */
-    contains(name: string): boolean;
-    /**
-     * Adds a graph node, or a nested cycle, to this group.
-     *
-     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} node
-     */
-    insert(node: PackageGraphNode | CyclicPackageGraphNode): void;
-    /**
-     * Remove pointers to candidate node from internal collections.
-     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} candidateNode instance to unlink
-     */
-    unlink(candidateNode: PackageGraphNode | CyclicPackageGraphNode): void;
-}
+import { PackageGraphNode } from '../../package-graph';
+/**
+ * Represents a cyclic collection of nodes in a PackageGraph.
+ * It is meant to be used as a black box, where the only exposed
+ * information are the connections to the other nodes of the graph.
+ * It can contain either `PackageGraphNode`s or other `CyclicPackageGraphNode`s.
+ *
+ * @extends {Map<string, import('..').PackageGraphNode | CyclicPackageGraphNode>}
+ */
+export declare class CyclicPackageGraphNode extends Map<string, PackageGraphNode | CyclicPackageGraphNode> {
+    name: string;
+    localDependencies: Map<string, any>;
+    localDependents: Map<string, any>;
+    constructor();
+    get isCycle(): boolean;
+    /**
+     * @returns {string} A representation of a cycle, like like `A -> B -> C -> A`.
+     */
+    toString(): string;
+    /**
+     * Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
+     */
+    flatten(): PackageGraphNode[];
+    /**
+     * Checks if a given node is contained in this cycle (or in a nested one)
+     *
+     * @param {string} name The name of the package to search in this cycle
+     * @returns {boolean}
+     */
+    contains(name: string): boolean;
+    /**
+     * Adds a graph node, or a nested cycle, to this group.
+     *
+     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} node
+     */
+    insert(node: PackageGraphNode | CyclicPackageGraphNode): void;
+    /**
+     * Remove pointers to candidate node from internal collections.
+     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} candidateNode instance to unlink
+     */
+    unlink(candidateNode: PackageGraphNode | CyclicPackageGraphNode): void;
+}

package/dist/package-graph/lib/cyclic-package-graph-node.js

@@ -1,98 +1,98 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CyclicPackageGraphNode = void 0;
-let lastCollapsedNodeId = 0;
-/**
- * Represents a cyclic collection of nodes in a PackageGraph.
- * It is meant to be used as a black box, where the only exposed
- * information are the connections to the other nodes of the graph.
- * It can contain either `PackageGraphNode`s or other `CyclicPackageGraphNode`s.
- *
- * @extends {Map<string, import('..').PackageGraphNode | CyclicPackageGraphNode>}
- */
-class CyclicPackageGraphNode extends Map {
-    constructor() {
-        super();
-        this.name = `(cycle) ${(lastCollapsedNodeId += 1)}`;
-        this.localDependencies = new Map();
-        this.localDependents = new Map();
-    }
-    // eslint-disable-next-line class-methods-use-this
-    get isCycle() {
-        return true;
-    }
-    /**
-     * @returns {string} A representation of a cycle, like like `A -> B -> C -> A`.
-     */
-    toString() {
-        const parts = Array.from(this, ([key, node]) => node.isCycle ? `(nested cycle: ${node.toString()})` : key);
-        // start from the origin
-        parts.push(parts[0]);
-        return parts.reverse().join(' -> ');
-    }
-    /**
-     * Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
-     */
-    flatten() {
-        const result = [];
-        for (const node of this.values()) {
-            if (node.isCycle) {
-                result.push(...node.flatten());
-            }
-            else {
-                result.push(node);
-            }
-        }
-        return result;
-    }
-    /**
-     * Checks if a given node is contained in this cycle (or in a nested one)
-     *
-     * @param {string} name The name of the package to search in this cycle
-     * @returns {boolean}
-     */
-    contains(name) {
-        for (const [currentName, currentNode] of this) {
-            if (currentNode.isCycle) {
-                if (currentNode.contains(name)) {
-                    return true;
-                }
-            }
-            else if (currentName === name) {
-                return true;
-            }
-        }
-        return false;
-    }
-    /**
-     * Adds a graph node, or a nested cycle, to this group.
-     *
-     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} node
-     */
-    insert(node) {
-        this.set(node.name, node);
-        this.unlink(node);
-        for (const [dependencyName, dependencyNode] of node.localDependencies) {
-            if (!this.contains(dependencyName)) {
-                this.localDependencies.set(dependencyName, dependencyNode);
-            }
-        }
-        for (const [dependentName, dependentNode] of node.localDependents) {
-            if (!this.contains(dependentName)) {
-                this.localDependents.set(dependentName, dependentNode);
-            }
-        }
-    }
-    /**
-     * Remove pointers to candidate node from internal collections.
-     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} candidateNode instance to unlink
-     */
-    unlink(candidateNode) {
-        // remove incoming edges ("indegree")
-        this.localDependencies.delete(candidateNode.name);
-        // remove outgoing edges ("outdegree")
-        this.localDependents.delete(candidateNode.name);
-    }
-}
-exports.CyclicPackageGraphNode = CyclicPackageGraphNode;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclicPackageGraphNode = void 0;
+let lastCollapsedNodeId = 0;
+/**
+ * Represents a cyclic collection of nodes in a PackageGraph.
+ * It is meant to be used as a black box, where the only exposed
+ * information are the connections to the other nodes of the graph.
+ * It can contain either `PackageGraphNode`s or other `CyclicPackageGraphNode`s.
+ *
+ * @extends {Map<string, import('..').PackageGraphNode | CyclicPackageGraphNode>}
+ */
+class CyclicPackageGraphNode extends Map {
+    constructor() {
+        super();
+        this.name = `(cycle) ${(lastCollapsedNodeId += 1)}`;
+        this.localDependencies = new Map();
+        this.localDependents = new Map();
+    }
+    // eslint-disable-next-line class-methods-use-this
+    get isCycle() {
+        return true;
+    }
+    /**
+     * @returns {string} A representation of a cycle, like like `A -> B -> C -> A`.
+     */
+    toString() {
+        const parts = Array.from(this, ([key, node]) => node.isCycle ? `(nested cycle: ${node.toString()})` : key);
+        // start from the origin
+        parts.push(parts[0]);
+        return parts.reverse().join(' -> ');
+    }
+    /**
+     * Flattens a CyclicPackageGraphNode (which can have multiple level of cycles).
+     */
+    flatten() {
+        const result = [];
+        for (const node of this.values()) {
+            if (node.isCycle) {
+                result.push(...node.flatten());
+            }
+            else {
+                result.push(node);
+            }
+        }
+        return result;
+    }
+    /**
+     * Checks if a given node is contained in this cycle (or in a nested one)
+     *
+     * @param {string} name The name of the package to search in this cycle
+     * @returns {boolean}
+     */
+    contains(name) {
+        for (const [currentName, currentNode] of this) {
+            if (currentNode.isCycle) {
+                if (currentNode.contains(name)) {
+                    return true;
+                }
+            }
+            else if (currentName === name) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Adds a graph node, or a nested cycle, to this group.
+     *
+     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} node
+     */
+    insert(node) {
+        this.set(node.name, node);
+        this.unlink(node);
+        for (const [dependencyName, dependencyNode] of node.localDependencies) {
+            if (!this.contains(dependencyName)) {
+                this.localDependencies.set(dependencyName, dependencyNode);
+            }
+        }
+        for (const [dependentName, dependentNode] of node.localDependents) {
+            if (!this.contains(dependentName)) {
+                this.localDependents.set(dependentName, dependentNode);
+            }
+        }
+    }
+    /**
+     * Remove pointers to candidate node from internal collections.
+     * @param {import('..').PackageGraphNode | CyclicPackageGraphNode} candidateNode instance to unlink
+     */
+    unlink(candidateNode) {
+        // remove incoming edges ("indegree")
+        this.localDependencies.delete(candidateNode.name);
+        // remove outgoing edges ("outdegree")
+        this.localDependents.delete(candidateNode.name);
+    }
+}
+exports.CyclicPackageGraphNode = CyclicPackageGraphNode;
 //# sourceMappingURL=cyclic-package-graph-node.js.map

package/dist/package-graph/lib/index.d.ts

@@ -1,3 +1,3 @@
-export * from './cyclic-package-graph-node';
-export * from './package-graph-node';
-export * from './report-cycles';
+export * from './cyclic-package-graph-node';
+export * from './package-graph-node';
+export * from './report-cycles';

package/dist/package-graph/lib/index.js

@@ -1,20 +1,20 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./cyclic-package-graph-node"), exports);
-__exportStar(require("./package-graph-node"), exports);
-__exportStar(require("./report-cycles"), exports);
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./cyclic-package-graph-node"), exports);
+__exportStar(require("./package-graph-node"), exports);
+__exportStar(require("./report-cycles"), exports);
 //# sourceMappingURL=index.js.map

package/dist/package-graph/lib/package-graph-node.d.ts

@@ -1,33 +1,33 @@
-import { Result } from 'npm-package-arg';
-import { Package } from '../../package';
-/**
- * A node in a PackageGraph.
- */
-export declare class PackageGraphNode {
-    name: string;
-    externalDependencies: Map<string, any>;
-    localDependencies: Map<string, any>;
-    localDependents: Map<string, any>;
-    /**
-     * @param {import("@lerna/package").Package} pkg
-     */
-    constructor(pkg: Package);
-    get location(): string;
-    get pkg(): Package;
-    get prereleaseId(): string | undefined;
-    get version(): string;
-    /**
-     * Determine if the Node satisfies a resolved semver range.
-     * @see https://github.com/npm/npm-package-arg#result-object
-     *
-     * @param {!Result} resolved npm-package-arg Result object
-     * @returns {Boolean}
-     */
-    satisfies({ gitCommittish, gitRange, fetchSpec }: Partial<Result>): boolean;
-    /**
-     * Returns a string representation of this node (its name)
-     *
-     * @returns {String}
-     */
-    toString(): string;
-}
+import { Result } from 'npm-package-arg';
+import { Package } from '../../package';
+/**
+ * A node in a PackageGraph.
+ */
+export declare class PackageGraphNode {
+    name: string;
+    externalDependencies: Map<string, any>;
+    localDependencies: Map<string, any>;
+    localDependents: Map<string, any>;
+    /**
+     * @param {import("@lerna/package").Package} pkg
+     */
+    constructor(pkg: Package);
+    get location(): string;
+    get pkg(): Package;
+    get prereleaseId(): string | undefined;
+    get version(): string;
+    /**
+     * Determine if the Node satisfies a resolved semver range.
+     * @see https://github.com/npm/npm-package-arg#result-object
+     *
+     * @param {!Result} resolved npm-package-arg Result object
+     * @returns {Boolean}
+     */
+    satisfies({ gitCommittish, gitRange, fetchSpec }: Partial<Result>): boolean;
+    /**
+     * Returns a string representation of this node (its name)
+     *
+     * @returns {String}
+     */
+    toString(): string;
+}