@alchemy.run/node-utils 0.0.4 → 2.0.0-beta.72

package/src/ignore.ts

@@ -1,40 +1,11 @@
-// @ts-nocheck
-/*
- * Vendored copy of `ignore` (https://github.com/kaelzhang/node-ignore)
- * Version: 7.0.5
- *
- * The body below is a mechanical copy of upstream `index.js`. The only
- * substantive change is the CommonJS export footer, which has been rewritten
- * as ES module exports; the upstream `index.d.ts` declarations are appended.
- *
- * ---------------------------------------------------------------------------
- * Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors
- * http://kael.me/
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- * ---------------------------------------------------------------------------
- */
-
-// A simple implementation of make-array
-function makeArray(subject) {
-  return Array.isArray(subject) ? subject : [subject];
+// Alchemy modifications are licensed under Apache-2.0.
+// This file includes third-party code; see /THIRD_PARTY_LICENSES.md.
+//
+// TypeScript port of `ignore` (https://github.com/kaelzhang/node-ignore) v7.0.5.
+// Copyright (c) 2013 Kael Zhang <i@kael.me>, contributors. MIT License.
+
+function makeArray<T>(subject: T | readonly T[]): T[] {
+  return Array.isArray(subject) ? [...subject] : [subject as T];
 }
 
 const UNDEFINED = undefined;
@@ -62,14 +33,14 @@ const REGEX_TEST_TRAILING_SLASH = /\/$/;
 const SLASH = "/";
 
 // Do not use ternary expression here, since "istanbul ignore next" is buggy
-let TMP_KEY_IGNORE = "node-ignore";
+let TMP_KEY_IGNORE: string | symbol = "node-ignore";
 /* istanbul ignore else */
 if (typeof Symbol !== "undefined") {
   TMP_KEY_IGNORE = Symbol.for("node-ignore");
 }
 const KEY_IGNORE = TMP_KEY_IGNORE;
 
-const define = (object, key, value) => {
+const define = <T>(object: object, key: PropertyKey, value: T): T => {
   Object.defineProperty(object, key, { value });
   return value;
 };
@@ -80,7 +51,7 @@ const RETURN_FALSE = () => false;
 
 // Sanitize the range of a regular expression
 // The cases are complicated, see test cases for details
-const sanitizeRange = (range) =>
+const sanitizeRange = (range: string): string =>
   range.replace(REGEX_REGEXP_RANGE, (match, from, to) =>
     from.charCodeAt(0) <= to.charCodeAt(0)
       ? match
@@ -89,8 +60,18 @@ const sanitizeRange = (range) =>
         EMPTY,
   );
 
+// > An optional `!` or `^` at the start of a class negates it, so that it
+// >   matches any character not in the set. (gitignore(5), fnmatch(3))
+// The leading `^` has already been escaped to `\^` by the metacharacter
+//   escaper, so we strip the literal `!` or escaped `^` and emit a single
+//   regex `^` which is the JavaScript negation token.
+const negateRange = (range: string): string =>
+  range.startsWith("!") || range.startsWith("\\^")
+    ? `^${range.slice(range[0] === "!" ? 1 : 2)}`
+    : range;
+
 // See fixtures #59
-const cleanRangeBackSlash = (slashes) => {
+const cleanRangeBackSlash = (slashes: string): string => {
   const { length } = slashes;
   return slashes.slice(0, length - (length % 2));
 };
@@ -106,7 +87,9 @@ const cleanRangeBackSlash = (slashes) => {
 //      you could use option `mark: true` with `glob`
 
 // '`foo/`' should not continue with the '`..`'
-const REPLACERS = [
+type Replacer = (this: string, ...args: any[]) => string;
+
+const REPLACERS: Array<readonly [RegExp, Replacer]> = [
   [
     // Remove BOM
     // TODO:
@@ -181,7 +164,7 @@ const REPLACERS = [
     // > "**/foo/bar" matches file or directory "bar" anywhere that is directly
     // >   under directory "foo".
     // Notice that the '*'s have been replaced as '\\*'
-    /^\^*\\\*\\\*\\\//,
+    /^\^*(?:\\\*\\\*\\\/)+/,
 
     // '**/foo' <-> 'foo'
     () => "^(?:.*\\/)?",
@@ -193,7 +176,7 @@ const REPLACERS = [
     //   (which has been replaced by section "leading slash")
     // If starts with '**', adding a '^' to the regular expression also works
     /^(?=[^^])/,
-    function startingReplacer() {
+    function startingReplacer(this: string) {
       // If has a slash `/` at the beginning or middle
       return !/\/(?!$)/.test(this)
         ? // > Prior to 2.22.1
@@ -291,7 +274,7 @@ const REPLACERS = [
             ? // A normal case, and it is a range notation
               // '[bar]'
               // '[bar\\\\]'
-              `[${sanitizeRange(range)}${endEscape}]`
+              `[${negateRange(sanitizeRange(range))}${endEscape}]`
             : // Invalid range notaton
               // '[bar\\]' -> '[bar\\\\]'
               "[]"
@@ -328,10 +311,11 @@ const REPLACERS = [
 const REGEX_REPLACE_TRAILING_WILDCARD = /(^|\\\/)?\\\*$/;
 const MODE_IGNORE = "regex";
 const MODE_CHECK_IGNORE = "checkRegex";
-const UNDERSCORE = "_";
 
-const TRAILING_WILD_CARD_REPLACERS = {
-  [MODE_IGNORE](_, p1) {
+type MatcherMode = typeof MODE_IGNORE | typeof MODE_CHECK_IGNORE;
+
+const TRAILING_WILD_CARD_REPLACERS: Record<MatcherMode, Replacer> = {
+  [MODE_IGNORE](_, p1: string | undefined) {
     const prefix = p1
       ? // '\^':
         // '/*' does not match EMPTY
@@ -347,7 +331,7 @@ const TRAILING_WILD_CARD_REPLACERS = {
     return `${prefix}(?=$|\\/$)`;
   },
 
-  [MODE_CHECK_IGNORE](_, p1) {
+  [MODE_CHECK_IGNORE](_, p1: string | undefined) {
     // When doing `git check-ignore`
     const prefix = p1
       ? // '\\\/':
@@ -362,29 +346,47 @@ const TRAILING_WILD_CARD_REPLACERS = {
 };
 
 // @param {pattern}
-const makeRegexPrefix = (pattern) =>
+const makeRegexPrefix = (pattern: string): string =>
   REPLACERS.reduce(
     (prev, [matcher, replacer]) =>
       prev.replace(matcher, replacer.bind(pattern)),
     pattern,
   );
 
-const isString = (subject) => typeof subject === "string";
+const isString = (subject: unknown): subject is string =>
+  typeof subject === "string";
 
 // > A blank line matches no files, so it can serve as a separator for readability.
-const checkPattern = (pattern) =>
-  pattern &&
-  isString(pattern) &&
-  !REGEX_TEST_BLANK_LINE.test(pattern) &&
-  !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) &&
-  // > A line starting with # serves as a comment.
-  pattern.indexOf("#") !== 0;
-
-const splitPattern = (pattern) =>
+const checkPattern = (pattern: string): boolean =>
+  Boolean(
+    pattern &&
+    !REGEX_TEST_BLANK_LINE.test(pattern) &&
+    !REGEX_INVALID_TRAILING_BACKSLASH.test(pattern) &&
+    // > A line starting with # serves as a comment.
+    pattern.indexOf("#") !== 0,
+  );
+
+const splitPattern = (pattern: string): string[] =>
   pattern.split(REGEX_SPLITALL_CRLF).filter(Boolean);
 
 class IgnoreRule {
-  constructor(pattern, mark, body, ignoreCase, negative, prefix) {
+  readonly pattern: string;
+  readonly mark: string | undefined;
+  readonly negative: boolean;
+  readonly body!: string;
+  readonly ignoreCase!: boolean;
+  readonly regexPrefix!: string;
+  private _regex?: RegExp;
+  private _checkRegex?: RegExp;
+
+  constructor(
+    pattern: string,
+    mark: string | undefined,
+    body: string,
+    ignoreCase: boolean,
+    negative: boolean,
+    prefix: string,
+  ) {
     this.pattern = pattern;
     this.mark = mark;
     this.negative = negative;
@@ -395,7 +397,7 @@ class IgnoreRule {
   }
 
   get regex() {
-    const key = UNDERSCORE + MODE_IGNORE;
+    const key = `_${MODE_IGNORE}` as const;
 
     if (this[key]) {
       return this[key];
@@ -405,7 +407,7 @@ class IgnoreRule {
   }
 
   get checkRegex() {
-    const key = UNDERSCORE + MODE_CHECK_IGNORE;
+    const key = `_${MODE_CHECK_IGNORE}` as const;
 
     if (this[key]) {
       return this[key];
@@ -414,7 +416,7 @@ class IgnoreRule {
     return this._make(MODE_CHECK_IGNORE, key);
   }
 
-  _make(mode, key) {
+  _make(mode: MatcherMode, key: "_regex" | "_checkRegex"): RegExp {
     const str = this.regexPrefix.replace(
       REGEX_REPLACE_TRAILING_WILDCARD,
 
@@ -428,7 +430,10 @@ class IgnoreRule {
   }
 }
 
-const createRule = ({ pattern, mark }, ignoreCase) => {
+const createRule = (
+  { pattern, mark }: PatternParams,
+  ignoreCase: boolean,
+): IgnoreRule => {
   let negative = false;
   let body = pattern;
 
@@ -452,15 +457,19 @@ const createRule = ({ pattern, mark }, ignoreCase) => {
 };
 
 class RuleManager {
-  constructor(ignoreCase) {
+  private readonly _ignoreCase: boolean;
+  _rules: IgnoreRule[] = [];
+  private _added = false;
+
+  constructor(ignoreCase: boolean) {
     this._ignoreCase = ignoreCase;
-    this._rules = [];
   }
 
-  _add(pattern) {
+  _add(pattern: string | Ignore | PatternParams): void {
     // #32
-    if (pattern && pattern[KEY_IGNORE]) {
-      this._rules = this._rules.concat(pattern._rules._rules);
+    const ignorePattern = pattern as Ignore & Record<PropertyKey, unknown>;
+    if (pattern && ignorePattern[KEY_IGNORE]) {
+      this._rules = this._rules.concat(ignorePattern._rules._rules);
       this._added = true;
       return;
     }
@@ -471,21 +480,28 @@ class RuleManager {
       };
     }
 
-    if (checkPattern(pattern.pattern)) {
-      const rule = createRule(pattern, this._ignoreCase);
+    const patternParams = pattern as PatternParams;
+    if (checkPattern(patternParams.pattern)) {
+      const rule = createRule(patternParams, this._ignoreCase);
       this._added = true;
       this._rules.push(rule);
     }
   }
 
   // @param {Array<string> | string | Ignore} pattern
-  add(pattern) {
+  add(
+    pattern: string | Ignore | PatternParams | readonly (string | Ignore)[],
+  ): boolean {
     this._added = false;
 
-    makeArray(isString(pattern) ? splitPattern(pattern) : pattern).forEach(
-      this._add,
-      this,
-    );
+    const patterns: readonly (string | Ignore | PatternParams)[] = isString(
+      pattern,
+    )
+      ? splitPattern(pattern)
+      : Array.isArray(pattern)
+        ? pattern
+        : [pattern as Ignore | PatternParams];
+    patterns.forEach(this._add, this);
 
     return this._added;
   }
@@ -498,10 +514,14 @@ class RuleManager {
   // - check `string` either `MODE_IGNORE` or `MODE_CHECK_IGNORE`
 
   // @returns {TestResult} true if a file is ignored
-  test(path, checkUnignored, mode) {
+  test(
+    path: string,
+    checkUnignored: boolean,
+    mode: MatcherMode,
+  ): IgnoreTestResult {
     let ignored = false;
     let unignored = false;
-    let matchedRule;
+    let matchedRule: IgnoreRule | undefined;
 
     this._rules.forEach((rule) => {
       const { negative } = rule;
@@ -536,7 +556,7 @@ class RuleManager {
       matchedRule = negative ? UNDEFINED : rule;
     });
 
-    const ret = {
+    const ret: IgnoreTestResult = {
       ignored,
       unignored,
     };
@@ -549,11 +569,23 @@ class RuleManager {
   }
 }
 
-const throwError = (message, Ctor) => {
+type ErrorConstructor = new (message: string) => Error;
+type InvalidPathHandler = (
+  message: string,
+  constructor: ErrorConstructor,
+) => boolean;
+
+const throwError: InvalidPathHandler = (message, Ctor) => {
   throw new Ctor(message);
 };
 
-const checkPath = (path, originalPath, doThrow) => {
+interface CheckPath {
+  (path: unknown, originalPath: unknown, doThrow: InvalidPathHandler): boolean;
+  isNotRelative: (path: string) => boolean;
+  convert: (path: string) => string;
+}
+
+const checkPath: CheckPath = (path, originalPath, doThrow) => {
   if (!isString(path)) {
     return doThrow(
       `path must be a string, but got \`${originalPath}\``,
@@ -578,20 +610,27 @@ const checkPath = (path, originalPath, doThrow) => {
   return true;
 };
 
-const isNotRelative = (path) => REGEX_TEST_INVALID_PATH.test(path);
+const isNotRelative = (path: string): boolean =>
+  REGEX_TEST_INVALID_PATH.test(path);
 
 checkPath.isNotRelative = isNotRelative;
 
 // On windows, the following function will be replaced
 /* istanbul ignore next */
-checkPath.convert = (p) => p;
+checkPath.convert = (path) => path;
 
 class Ignore {
+  readonly [KEY_IGNORE]?: true;
+  readonly _rules: RuleManager;
+  private readonly _strictPathCheck: boolean;
+  private _ignoreCache!: Record<string, IgnoreTestResult>;
+  private _testCache!: Record<string, IgnoreTestResult>;
+
   constructor({
     ignorecase = true,
     ignoreCase = ignorecase,
     allowRelativePaths = false,
-  } = {}) {
+  }: IgnoreOptions = {}) {
     define(this, KEY_IGNORE, true);
 
     this._rules = new RuleManager(ignoreCase);
@@ -599,7 +638,7 @@ class Ignore {
     this._initCache();
   }
 
-  _initCache() {
+  _initCache(): void {
     // A cache for the result of `.ignores()`
     this._ignoreCache = Object.create(null);
 
@@ -607,7 +646,9 @@ class Ignore {
     this._testCache = Object.create(null);
   }
 
-  add(pattern) {
+  add(
+    pattern: string | Ignore | readonly (string | Ignore)[] | PatternParams,
+  ): this {
     if (this._rules.add(pattern)) {
       // Some rules have just added to the ignore,
       //   making the behavior changed,
@@ -619,12 +660,17 @@ class Ignore {
   }
 
   // legacy
-  addPattern(pattern) {
+  addPattern(pattern: string | readonly string[]): this {
     return this.add(pattern);
   }
 
   // @returns {TestResult}
-  _test(originalPath, cache, checkUnignored, slices) {
+  _test(
+    originalPath: string,
+    cache: Record<string, IgnoreTestResult>,
+    checkUnignored: boolean,
+    slices?: string[],
+  ): IgnoreTestResult {
     const path =
       originalPath &&
       // Supports nullable path
@@ -639,7 +685,7 @@ class Ignore {
     return this._t(path, cache, checkUnignored, slices);
   }
 
-  checkIgnore(path) {
+  checkIgnore(path: string): IgnoreTestResult {
     // If the path doest not end with a slash, `.ignores()` is much equivalent
     //   to `git check-ignore`
     if (!REGEX_TEST_TRAILING_SLASH.test(path)) {
@@ -667,17 +713,17 @@ class Ignore {
 
   _t(
     // The path to be tested
-    path,
+    path: string,
 
     // The cache for the result of a certain checking
-    cache,
+    cache: Record<string, IgnoreTestResult>,
 
     // Whether should check if the path is unignored
-    checkUnignored,
+    checkUnignored: boolean,
 
     // The path slices
-    slices,
-  ) {
+    slices?: string[],
+  ): IgnoreTestResult {
     if (path in cache) {
       return cache[path];
     }
@@ -714,33 +760,33 @@ class Ignore {
       : this._rules.test(path, checkUnignored, MODE_IGNORE));
   }
 
-  ignores(path) {
+  ignores(path: string): boolean {
     return this._test(path, this._ignoreCache, false).ignored;
   }
 
-  createFilter() {
-    return (path) => !this.ignores(path);
+  createFilter(): (path: string) => boolean {
+    return (path: string) => !this.ignores(path);
   }
 
-  filter(paths) {
+  filter(paths: readonly string[]): string[] {
     return makeArray(paths).filter(this.createFilter());
   }
 
   // @returns {TestResult}
-  test(path) {
+  test(path: string): IgnoreTestResult {
     return this._test(path, this._testCache, true);
   }
 }
 
-const factory = (options) => new Ignore(options);
+const factory = (options?: IgnoreOptions): Ignore => new Ignore(options);
 
-const isPathValid = (path) =>
+const isPathValid = (path: string): boolean =>
   checkPath(path && checkPath.convert(path), path, RETURN_FALSE);
 
 /* istanbul ignore next */
 const setupWindows = () => {
   /* eslint no-control-regex: "off" */
-  const makePosix = (str) =>
+  const makePosix = (str: string): string =>
     /^\\\\\?\\/.test(str) || /["<>|\u0000-\u001F]+/u.test(str)
       ? str
       : str.replace(/\\/g, "/");
@@ -750,7 +796,7 @@ const setupWindows = () => {
   // 'C:\\foo'     <- 'C:\\foo' has been converted to 'C:/'
   // 'd:\\foo'
   const REGEX_TEST_WINDOWS_PATH_ABSOLUTE = /^[a-z]:\//i;
-  checkPath.isNotRelative = (path) =>
+  checkPath.isNotRelative = (path: string) =>
     REGEX_TEST_WINDOWS_PATH_ABSOLUTE.test(path) || isNotRelative(path);
 };
 
@@ -772,7 +818,7 @@ if (
 export default factory as unknown as (
   options?: IgnoreOptions,
 ) => IgnoreInstance;
-export { isPathValid };
+export { Ignore, isPathValid };
 
 // --- Type declarations -----------------------------------------------------
 // (not part of the verbatim upstream source; mirrors upstream `index.d.ts`)
@@ -784,6 +830,12 @@ interface PatternParams {
   mark?: string;
 }
 
+interface IgnoreTestResult {
+  ignored: boolean;
+  unignored: boolean;
+  rule?: IgnoreRule;
+}
+
 export interface IgnoreOptions {
   ignorecase?: boolean;
   /** For compatibility. */

package/lib/adapter.d.ts

@@ -1,14 +0,0 @@
-type AnyFs = Record<string, any>;
-type AsyncMethod = (...args: any[]) => void;
-export declare function toPromise<T = any>(method: AsyncMethod): (...args: any[]) => Promise<T>;
-export declare function toSync<T = any>(method: AsyncMethod): (...args: any[]) => T;
-export interface SyncOptions {
-    fs?: AnyFs;
-    retries?: number | {
-        retries?: number;
-    };
-    [key: string]: any;
-}
-export declare function toSyncOptions(options?: SyncOptions): SyncOptions;
-export {};
-//# sourceMappingURL=adapter.d.ts.map

package/lib/adapter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAEA,KAAK,KAAK,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEjC,KAAK,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AA0B5C,wBAAgB,SAAS,CAAC,CAAC,GAAG,GAAG,EAC/B,MAAM,EAAE,WAAW,GAClB,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,CAahC;AAED,wBAAgB,MAAM,CAAC,CAAC,GAAG,GAAG,EAAE,MAAM,EAAE,WAAW,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAkB1E;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,CAAC,EAAE,KAAK,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,GAAG;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxC,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,wBAAgB,aAAa,CAAC,OAAO,CAAC,EAAE,WAAW,GAAG,WAAW,CAoBhE"}

package/lib/adapter.js

@@ -1,65 +0,0 @@
-import fs from "node:fs";
-function createSyncFs(fs) {
-    const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-    const newFs = { ...fs };
-    methods.forEach((method) => {
-        newFs[method] = (...args) => {
-            const callback = args.pop();
-            let ret;
-            try {
-                ret = fs[`${method}Sync`](...args);
-            }
-            catch (err) {
-                return callback(err);
-            }
-            callback(null, ret);
-        };
-    });
-    return newFs;
-}
-// ----------------------------------------------------------
-export function toPromise(method) {
-    return (...args) => new Promise((resolve, reject) => {
-        args.push((err, result) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve(result);
-            }
-        });
-        method(...args);
-    });
-}
-export function toSync(method) {
-    return (...args) => {
-        let err;
-        let result;
-        args.push((_err, _result) => {
-            err = _err;
-            result = _result;
-        });
-        method(...args);
-        if (err) {
-            throw err;
-        }
-        return result;
-    };
-}
-export function toSyncOptions(options) {
-    // Shallow clone options because we are going to mutate them
-    const next = { ...options };
-    // Transform fs to use the sync methods instead
-    next.fs = createSyncFs(next.fs || fs);
-    // Retries are not allowed because it requires the flow to be sync
-    if ((typeof next.retries === "number" && next.retries > 0) ||
-        (next.retries &&
-            typeof next.retries.retries === "number" &&
-            next.retries.retries > 0)) {
-        throw Object.assign(new Error("Cannot use retries with the sync api"), {
-            code: "ESYNC",
-        });
-    }
-    return next;
-}
-//# sourceMappingURL=adapter.js.map

package/lib/adapter.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"adapter.js","sourceRoot":"","sources":["../src/adapter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,SAAS,CAAC;AAMzB,SAAS,YAAY,CAAC,EAAS;IAC7B,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,QAAQ,CAAU,CAAC;IAC1E,MAAM,KAAK,GAAU,EAAE,GAAG,EAAE,EAAE,CAAC;IAE/B,OAAO,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE;QACzB,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAW,EAAE,EAAE;YACjC,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAiB,CAAC;YAC3C,IAAI,GAAG,CAAC;YAER,IAAI,CAAC;gBACH,GAAG,GAAG,EAAE,CAAC,GAAG,MAAM,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;YACrC,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,OAAO,QAAQ,CAAC,GAA4B,CAAC,CAAC;YAChD,CAAC;YAED,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QACtB,CAAC,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,OAAO,KAAK,CAAC;AACf,CAAC;AAED,6DAA6D;AAE7D,MAAM,UAAU,SAAS,CACvB,MAAmB;IAEnB,OAAO,CAAC,GAAG,IAAW,EAAE,EAAE,CACxB,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACjC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAiC,EAAE,MAAS,EAAE,EAAE;YACzD,IAAI,GAAG,EAAE,CAAC;gBACR,MAAM,CAAC,GAAG,CAAC,CAAC;YACd,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,MAAM,CAAC,CAAC;YAClB,CAAC;QACH,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;IAClB,CAAC,CAAC,CAAC;AACP,CAAC;AAED,MAAM,UAAU,MAAM,CAAU,MAAmB;IACjD,OAAO,CAAC,GAAG,IAAW,EAAE,EAAE;QACxB,IAAI,GAA6C,CAAC;QAClD,IAAI,MAAqB,CAAC;QAE1B,IAAI,CAAC,IAAI,CAAC,CAAC,IAAkC,EAAE,OAAU,EAAE,EAAE;YAC3D,GAAG,GAAG,IAAI,CAAC;YACX,MAAM,GAAG,OAAO,CAAC;QACnB,CAAC,CAAC,CAAC;QAEH,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC;QAEhB,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,GAAG,CAAC;QACZ,CAAC;QAED,OAAO,MAAW,CAAC;IACrB,CAAC,CAAC;AACJ,CAAC;AAQD,MAAM,UAAU,aAAa,CAAC,OAAqB;IACjD,4DAA4D;IAC5D,MAAM,IAAI,GAAgB,EAAE,GAAG,OAAO,EAAE,CAAC;IAEzC,+CAA+C;IAC/C,IAAI,CAAC,EAAE,GAAG,YAAY,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC;IAEtC,kEAAkE;IAClE,IACE,CAAC,OAAO,IAAI,CAAC,OAAO,KAAK,QAAQ,IAAI,IAAI,CAAC,OAAO,GAAG,CAAC,CAAC;QACtD,CAAC,IAAI,CAAC,OAAO;YACX,OAAQ,IAAI,CAAC,OAAgC,CAAC,OAAO,KAAK,QAAQ;YAChE,IAAI,CAAC,OAAgC,CAAC,OAAkB,GAAG,CAAC,CAAC,EACjE,CAAC;QACD,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,sCAAsC,CAAC,EAAE;YACrE,IAAI,EAAE,OAAO;SACd,CAAC,CAAC;IACL,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/lib/exit-hook.d.ts

@@ -1,22 +0,0 @@
-/**
- * Lightweight replacement for the `exit-hook` npm package.
- *
- * The third-party `exit-hook` registers process listeners (`exit`, `SIGINT`,
- * `SIGTERM`, and `message`) that are never removed — even after every
- * callback has been unregistered.  Those dangling listeners are harmless in
- * long-running processes, but in short-lived child processes (e.g. those
- * spawned by `node --test`) they can prevent clean exit by holding refs on
- * handles such as the IPC channel.
- *
- * This module tracks the number of active registrations and removes **all**
- * process listeners once the last registration is unregistered, so they
- * cannot keep the event loop alive after dispose.
- */
-/**
- * Register a callback to run when the process exits.  Returns a function
- * that unregisters the callback.  When the last callback is unregistered,
- * all underlying process listeners are removed so they cannot keep the
- * event loop alive.
- */
-export declare function exitHook(callback: () => void): () => void;
-//# sourceMappingURL=exit-hook.d.ts.map

package/lib/exit-hook.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exit-hook.d.ts","sourceRoot":"","sources":["../src/exit-hook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AA+DH;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAazD"}