fast-glob-fast 4.0.0

package/out/settings.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+const fs = require("node:fs");
+exports.DEFAULT_FILE_SYSTEM_ADAPTER = {
+    lstat: fs.lstat,
+    lstatSync: fs.lstatSync,
+    stat: fs.stat,
+    statSync: fs.statSync,
+    readdir: fs.readdir,
+    readdirSync: fs.readdirSync,
+};
+class Settings {
+    absolute;
+    baseNameMatch;
+    braceExpansion;
+    caseSensitiveMatch;
+    cwd;
+    deep;
+    dot;
+    extglob;
+    followSymbolicLinks;
+    fs;
+    globstar;
+    ignore;
+    markDirectories;
+    objectMode;
+    onlyDirectories;
+    onlyFiles;
+    stats;
+    suppressErrors;
+    throwErrorOnBrokenSymbolicLink;
+    unique;
+    signal;
+    // eslint-disable-next-line complexity
+    constructor(options = {}) {
+        if (options.deep !== undefined && options.deep < 0) {
+            throw new TypeError(`options.deep must be a non-negative number, received: ${options.deep}`);
+        }
+        this.absolute = options.absolute ?? false;
+        this.baseNameMatch = options.baseNameMatch ?? false;
+        this.braceExpansion = options.braceExpansion ?? true;
+        this.caseSensitiveMatch = options.caseSensitiveMatch ?? true;
+        this.cwd = options.cwd ?? process.cwd();
+        this.deep = options.deep ?? Number.POSITIVE_INFINITY;
+        this.dot = options.dot ?? false;
+        this.extglob = options.extglob ?? true;
+        this.followSymbolicLinks = options.followSymbolicLinks ?? true;
+        this.fs = this.#getFileSystemMethods(options.fs);
+        this.globstar = options.globstar ?? true;
+        this.ignore = options.ignore ?? [];
+        this.markDirectories = options.markDirectories ?? false;
+        this.objectMode = options.objectMode ?? false;
+        this.onlyDirectories = options.onlyDirectories ?? false;
+        this.onlyFiles = options.onlyFiles ?? true;
+        this.stats = options.stats ?? false;
+        this.suppressErrors = options.suppressErrors ?? false;
+        this.throwErrorOnBrokenSymbolicLink = options.throwErrorOnBrokenSymbolicLink ?? false;
+        this.unique = options.unique ?? true;
+        this.signal = options.signal;
+        if (this.onlyDirectories) {
+            this.onlyFiles = false;
+        }
+        if (this.stats) {
+            this.objectMode = true;
+        }
+    }
+    #getFileSystemMethods(methods = {}) {
+        return {
+            ...exports.DEFAULT_FILE_SYSTEM_ADAPTER,
+            ...methods,
+        };
+    }
+}
+exports.default = Settings;

package/out/types/index.d.ts

@@ -0,0 +1,34 @@
+import type * as fs from 'node:fs';
+import type * as fsWalk from '@nodelib/fs.walk';
+export type Dictionary<T = unknown> = Record<string, T>;
+export type ErrnoException = NodeJS.ErrnoException;
+export type FsDirent = fs.Dirent;
+export type FsStats = fs.Stats;
+export type Entry = fsWalk.Entry;
+export type EntryItem = Entry | string;
+export type Pattern = string;
+export type PatternRe = RegExp;
+export type PatternsGroup = Dictionary<Pattern[]>;
+export type ReaderOptions = {
+    transform: (entry: Entry) => EntryItem;
+    deepFilter: DeepFilterFunction;
+    entryFilter: EntryFilterFunction;
+    errorFilter: ErrorFilterFunction;
+    fs: FileSystemAdapter;
+    stats: boolean;
+} & fsWalk.Options;
+export type ErrorFilterFunction = fsWalk.ErrorFilterFunction;
+export type EntryFilterFunction = fsWalk.EntryFilterFunction;
+export type DeepFilterFunction = fsWalk.DeepFilterFunction;
+export type EntryTransformerFunction = (entry: Entry) => EntryItem;
+export interface MicromatchOptions {
+    dot?: boolean;
+    matchBase?: boolean;
+    nobrace?: boolean;
+    nocase?: boolean;
+    noext?: boolean;
+    noglobstar?: boolean;
+    posix?: boolean;
+    strictSlashes?: boolean;
+}
+export type FileSystemAdapter = fsWalk.FileSystemAdapter;

package/out/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/out/utils/array.d.ts

@@ -0,0 +1,2 @@
+export declare function flatFirstLevel<T>(items: T[][]): T[];
+export declare function splitWhen<T>(items: T[], predicate: (item: T) => boolean): T[][];

package/out/utils/array.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatFirstLevel = flatFirstLevel;
+exports.splitWhen = splitWhen;
+function flatFirstLevel(items) {
+    // We do not use `Array.flat` because this is slower than current implementation for your case.
+    return [].concat(...items);
+}
+function splitWhen(items, predicate) {
+    const result = [[]];
+    let groupIndex = 0;
+    for (const item of items) {
+        if (predicate(item)) {
+            groupIndex++;
+            result[groupIndex] = [];
+        }
+        else {
+            result[groupIndex].push(item);
+        }
+    }
+    return result;
+}

package/out/utils/errno.d.ts

@@ -0,0 +1,2 @@
+import type { ErrnoException } from '../types';
+export declare function isEnoentCodeError(error: ErrnoException): boolean;

package/out/utils/errno.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnoentCodeError = isEnoentCodeError;
+function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+}

package/out/utils/fs.d.ts

@@ -0,0 +1,9 @@
+import * as fs from 'node:fs';
+import type { FsStats, FsDirent } from '../types';
+declare const _kStats: unique symbol;
+export declare class DirentFromStats extends fs.Dirent {
+    private readonly [_kStats];
+    constructor(name: string, stats: FsStats);
+}
+export declare function createDirentFromStats(name: string, stats: FsStats): FsDirent;
+export {};

package/out/utils/fs.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirentFromStats = void 0;
+exports.createDirentFromStats = createDirentFromStats;
+const fs = require("node:fs");
+const _kStats = Symbol('stats');
+// Adapting an internal class in Node.js to mimic the behavior of `fs.Dirent` when creating it manually from `fs.Stats`.
+// https://github.com/nodejs/node/blob/a4cf6b204f0b160480153dc293ae748bf15225f9/lib/internal/fs/utils.js#L199C1-L213
+class DirentFromStats extends fs.Dirent {
+    [_kStats];
+    constructor(name, stats) {
+        // @ts-expect-error The constructor has parameters, but they are not represented in types.
+        // https://github.com/nodejs/node/blob/a4cf6b204f0b160480153dc293ae748bf15225f9/lib/internal/fs/utils.js#L164
+        super(name, null);
+        this[_kStats] = stats;
+    }
+}
+exports.DirentFromStats = DirentFromStats;
+for (const key of Reflect.ownKeys(fs.Dirent.prototype)) {
+    const name = key;
+    if (name === 'constructor') {
+        continue;
+    }
+    DirentFromStats.prototype[name] = function () {
+        return this[_kStats][name]();
+    };
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}

package/out/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * as array from './array';
+export * as errno from './errno';
+export * as fs from './fs';
+export * as path from './path';
+export * as pattern from './pattern';
+export * as stream from './stream';
+export * as string from './string';

package/out/utils/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.string = exports.stream = exports.pattern = exports.path = exports.fs = exports.errno = exports.array = void 0;
+exports.array = require("./array");
+exports.errno = require("./errno");
+exports.fs = require("./fs");
+exports.path = require("./path");
+exports.pattern = require("./pattern");
+exports.stream = require("./stream");
+exports.string = require("./string");

package/out/utils/path.d.ts

@@ -0,0 +1,10 @@
+import type { Pattern } from '../types';
+export declare function makeAbsolute(cwd: string, filepath: string): string;
+export declare function removeLeadingDotSegment(entry: string): string;
+export declare function removeBackslashes(entry: string): string;
+export declare const escape: typeof escapeWindowsPath;
+export declare function escapeWindowsPath(pattern: Pattern): Pattern;
+export declare function escapePosixPath(pattern: Pattern): Pattern;
+export declare const convertPathToPattern: typeof convertWindowsPathToPattern;
+export declare function convertWindowsPathToPattern(filepath: string): Pattern;
+export declare function convertPosixPathToPattern(filepath: string): Pattern;

package/out/utils/path.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPathToPattern = exports.escape = void 0;
+exports.makeAbsolute = makeAbsolute;
+exports.removeLeadingDotSegment = removeLeadingDotSegment;
+exports.removeBackslashes = removeBackslashes;
+exports.escapeWindowsPath = escapeWindowsPath;
+exports.escapePosixPath = escapePosixPath;
+exports.convertWindowsPathToPattern = convertWindowsPathToPattern;
+exports.convertPosixPathToPattern = convertPosixPathToPattern;
+const os = require("node:os");
+const path = require("node:path");
+const IS_WINDOWS_PLATFORM = os.platform() === 'win32';
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+/**
+ * All non-escaped special characters.
+ * Posix: ()*?[]{|}, !+@ before (, ! at the beginning, \\ before non-special characters.
+ * Windows: (){}[], !+@ before (, ! at the beginning.
+ */
+const POSIX_UNESCAPED_GLOB_SYMBOLS_RE = /(?<escape>\\?)(?<symbols>[()*?[\]{|}]|^!|[!+@](?=\()|\\(?![!()*+?@[\]{|}]))/g;
+const WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE = /(?<escape>\\?)(?<symbols>[()[\]{}]|^!|[!+@](?=\())/g;
+/**
+ * The device path (\\.\ or \\?\).
+ * https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats#dos-device-paths
+ */
+const DOS_DEVICE_PATH_RE = /^\\\\(?<path>[.?])/;
+/**
+ * All backslashes except those escaping special characters.
+ * Windows: !()+@{}
+ * https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file#naming-conventions
+ */
+const WINDOWS_BACKSLASHES_RE = /\\(?![!()+@[\]{}])/g;
+function makeAbsolute(cwd, filepath) {
+    return path.resolve(cwd, filepath);
+}
+function removeLeadingDotSegment(entry) {
+    // We do not use `startsWith` because this is 10x slower than current implementation for some cases.
+    // eslint-disable-next-line @typescript-eslint/prefer-string-starts-ends-with
+    if (entry.charAt(0) === '.') {
+        const secondCharactery = entry.charAt(1);
+        if (secondCharactery === '/' || secondCharactery === '\\') {
+            return entry.slice(LEADING_DOT_SEGMENT_CHARACTERS_COUNT);
+        }
+    }
+    return entry;
+}
+function removeBackslashes(entry) {
+    return entry.replaceAll('\\', '');
+}
+exports.escape = IS_WINDOWS_PLATFORM ? escapeWindowsPath : escapePosixPath;
+function escapeWindowsPath(pattern) {
+    return pattern.replaceAll(WINDOWS_UNESCAPED_GLOB_SYMBOLS_RE, String.raw `\$2`);
+}
+function escapePosixPath(pattern) {
+    return pattern.replaceAll(POSIX_UNESCAPED_GLOB_SYMBOLS_RE, String.raw `\$2`);
+}
+exports.convertPathToPattern = IS_WINDOWS_PLATFORM ? convertWindowsPathToPattern : convertPosixPathToPattern;
+function convertWindowsPathToPattern(filepath) {
+    return escapeWindowsPath(filepath)
+        .replace(DOS_DEVICE_PATH_RE, '//$1')
+        .replaceAll(WINDOWS_BACKSLASHES_RE, '/');
+}
+function convertPosixPathToPattern(filepath) {
+    return escapePosixPath(filepath);
+}

package/out/utils/pattern.d.ts

@@ -0,0 +1,49 @@
+import type { MicromatchOptions, Pattern, PatternRe } from '../types';
+interface PatternTypeOptions {
+    braceExpansion?: boolean;
+    caseSensitiveMatch?: boolean;
+    extglob?: boolean;
+}
+export declare function isStaticPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function isDynamicPattern(pattern: Pattern, options?: PatternTypeOptions): boolean;
+export declare function convertToPositivePattern(pattern: Pattern): Pattern;
+export declare function convertToNegativePattern(pattern: Pattern): Pattern;
+export declare function isNegativePattern(pattern: Pattern): boolean;
+export declare function isPositivePattern(pattern: Pattern): boolean;
+export declare function getNegativePatterns(patterns: Pattern[]): Pattern[];
+export declare function getPositivePatterns(patterns: Pattern[]): Pattern[];
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+export declare function getPatternsInsideCurrentDirectory(patterns: Pattern[]): Pattern[];
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+export declare function getPatternsOutsideCurrentDirectory(patterns: Pattern[]): Pattern[];
+export declare function isPatternRelatedToParentDirectory(pattern: Pattern): boolean;
+export declare function getBaseDirectory(pattern: Pattern): string;
+export declare function hasGlobStar(pattern: Pattern): boolean;
+export declare function endsWithSlashGlobStar(pattern: Pattern): boolean;
+export declare function isAffectDepthOfReadingPattern(pattern: Pattern): boolean;
+export declare function expandPatternsWithBraceExpansion(patterns: Pattern[]): Pattern[];
+export declare function expandBraceExpansion(pattern: Pattern): Pattern[];
+export declare function getPatternParts(pattern: Pattern, options: MicromatchOptions): Pattern[];
+export declare function makeRe(pattern: Pattern, options: MicromatchOptions): PatternRe;
+export declare function convertPatternsToRe(patterns: Pattern[], options: MicromatchOptions): PatternRe[];
+export declare function matchAny(entry: string, patternsRe: PatternRe[]): boolean;
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+export declare function removeDuplicateSlashes(pattern: string): string;
+export declare function partitionAbsoluteAndRelative(patterns: Pattern[]): [Pattern[], Pattern[]];
+export declare function isAbsolute(pattern: string): boolean;
+export {};

package/out/utils/pattern.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isStaticPattern = isStaticPattern;
+exports.isDynamicPattern = isDynamicPattern;
+exports.convertToPositivePattern = convertToPositivePattern;
+exports.convertToNegativePattern = convertToNegativePattern;
+exports.isNegativePattern = isNegativePattern;
+exports.isPositivePattern = isPositivePattern;
+exports.getNegativePatterns = getNegativePatterns;
+exports.getPositivePatterns = getPositivePatterns;
+exports.getPatternsInsideCurrentDirectory = getPatternsInsideCurrentDirectory;
+exports.getPatternsOutsideCurrentDirectory = getPatternsOutsideCurrentDirectory;
+exports.isPatternRelatedToParentDirectory = isPatternRelatedToParentDirectory;
+exports.getBaseDirectory = getBaseDirectory;
+exports.hasGlobStar = hasGlobStar;
+exports.endsWithSlashGlobStar = endsWithSlashGlobStar;
+exports.isAffectDepthOfReadingPattern = isAffectDepthOfReadingPattern;
+exports.expandPatternsWithBraceExpansion = expandPatternsWithBraceExpansion;
+exports.expandBraceExpansion = expandBraceExpansion;
+exports.getPatternParts = getPatternParts;
+exports.makeRe = makeRe;
+exports.convertPatternsToRe = convertPatternsToRe;
+exports.matchAny = matchAny;
+exports.removeDuplicateSlashes = removeDuplicateSlashes;
+exports.partitionAbsoluteAndRelative = partitionAbsoluteAndRelative;
+exports.isAbsolute = isAbsolute;
+const path = require("node:path");
+// https://stackoverflow.com/a/39415662
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const globParent = require("glob-parent");
+const micromatch = require("micromatch");
+const GLOBSTAR = '**';
+const ESCAPE_SYMBOL = '\\';
+const COMMON_GLOB_SYMBOLS_RE = /[*?]|^!/;
+const REGEX_CHARACTER_CLASS_SYMBOLS_RE = /\[[^[]*]/;
+const REGEX_GROUP_SYMBOLS_RE = /(?:^|[^!*+?@])\([^(]*\|[^|]*\)/;
+const GLOB_EXTENSION_SYMBOLS_RE = /[!*+?@]\([^(]*\)/;
+const BRACE_EXPANSION_SEPARATORS_RE = /,|\.\./;
+/**
+ * Matches a sequence of two or more consecutive slashes, excluding the first two slashes at the beginning of the string.
+ * The latter is due to the presence of the device path at the beginning of the UNC path.
+ */
+const DOUBLE_SLASH_RE = /(?!^)\/{2,}/g;
+function isStaticPattern(pattern, options = {}) {
+    return !isDynamicPattern(pattern, options);
+}
+function isDynamicPattern(pattern, options = {}) {
+    /**
+     * A special case with an empty string is necessary for matching patterns that start with a forward slash.
+     * An empty string cannot be a dynamic pattern.
+     * For example, the pattern `/lib/*` will be spread into parts: '', 'lib', '*'.
+     */
+    if (pattern === '') {
+        return false;
+    }
+    /**
+     * When the `caseSensitiveMatch` option is disabled, all patterns must be marked as dynamic, because we cannot check
+     * filepath directly (without read directory).
+     */
+    if (options.caseSensitiveMatch === false || pattern.includes(ESCAPE_SYMBOL)) {
+        return true;
+    }
+    if (COMMON_GLOB_SYMBOLS_RE.test(pattern) || REGEX_CHARACTER_CLASS_SYMBOLS_RE.test(pattern) || REGEX_GROUP_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.extglob !== false && GLOB_EXTENSION_SYMBOLS_RE.test(pattern)) {
+        return true;
+    }
+    if (options.braceExpansion !== false && hasBraceExpansion(pattern)) {
+        return true;
+    }
+    return false;
+}
+function hasBraceExpansion(pattern) {
+    const openingBraceIndex = pattern.indexOf('{');
+    if (openingBraceIndex === -1) {
+        return false;
+    }
+    const closingBraceIndex = pattern.indexOf('}', openingBraceIndex + 1);
+    if (closingBraceIndex === -1) {
+        return false;
+    }
+    const braceContent = pattern.slice(openingBraceIndex, closingBraceIndex);
+    return BRACE_EXPANSION_SEPARATORS_RE.test(braceContent);
+}
+function convertToPositivePattern(pattern) {
+    return isNegativePattern(pattern) ? pattern.slice(1) : pattern;
+}
+function convertToNegativePattern(pattern) {
+    return `!${pattern}`;
+}
+function isNegativePattern(pattern) {
+    return pattern.startsWith('!') && pattern[1] !== '(';
+}
+function isPositivePattern(pattern) {
+    return !isNegativePattern(pattern);
+}
+function getNegativePatterns(patterns) {
+    return patterns.filter((pattern) => isNegativePattern(pattern));
+}
+function getPositivePatterns(patterns) {
+    return patterns.filter((pattern) => isPositivePattern(pattern));
+}
+/**
+ * Returns patterns that can be applied inside the current directory.
+ *
+ * @example
+ * // ['./*', '*', 'a/*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsInsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern) => !isPatternRelatedToParentDirectory(pattern));
+}
+/**
+ * Returns patterns to be expanded relative to (outside) the current directory.
+ *
+ * @example
+ * // ['../*', './../*']
+ * getPatternsInsideCurrentDirectory(['./*', '*', 'a/*', '../*', './../*'])
+ */
+function getPatternsOutsideCurrentDirectory(patterns) {
+    return patterns.filter((pattern) => isPatternRelatedToParentDirectory(pattern));
+}
+function isPatternRelatedToParentDirectory(pattern) {
+    return pattern.startsWith('..') || pattern.startsWith('./..');
+}
+function getBaseDirectory(pattern) {
+    return globParent(pattern, { flipBackslashes: false });
+}
+function hasGlobStar(pattern) {
+    return pattern.includes(GLOBSTAR);
+}
+function endsWithSlashGlobStar(pattern) {
+    return pattern.endsWith(`/${GLOBSTAR}`);
+}
+function isAffectDepthOfReadingPattern(pattern) {
+    const basename = path.basename(pattern);
+    return endsWithSlashGlobStar(pattern) || isStaticPattern(basename);
+}
+function expandPatternsWithBraceExpansion(patterns) {
+    return patterns.reduce((collection, pattern) => {
+        return collection.concat(expandBraceExpansion(pattern));
+    }, []);
+}
+function expandBraceExpansion(pattern) {
+    const patterns = micromatch.braces(pattern, { expand: true, nodupes: true, keepEscaping: true });
+    /**
+     * Sort the patterns by length so that the same depth patterns are processed side by side.
+     * `a/{b,}/{c,}/*` – `['a///*', 'a/b//*', 'a//c/*', 'a/b/c/*']`
+     */
+    patterns.sort((a, b) => a.length - b.length);
+    /**
+     * Micromatch can return an empty string in the case of patterns like `{a,}`.
+     */
+    return patterns.filter((pattern) => pattern !== '');
+}
+function getPatternParts(pattern, options) {
+    let { parts } = micromatch.scan(pattern, {
+        ...options,
+        parts: true,
+    });
+    /**
+     * The scan method returns an empty array in some cases.
+     * See micromatch/picomatch#58 for more details.
+     */
+    if (parts.length === 0) {
+        parts = [pattern];
+    }
+    /**
+     * The scan method does not return an empty part for the pattern with a forward slash.
+     * This is another part of micromatch/picomatch#58.
+     */
+    if (parts[0].startsWith('/')) {
+        parts[0] = parts[0].slice(1);
+        parts.unshift('');
+    }
+    return parts;
+}
+function makeRe(pattern, options) {
+    return micromatch.makeRe(pattern, options);
+}
+function convertPatternsToRe(patterns, options) {
+    return patterns.map((pattern) => makeRe(pattern, options));
+}
+function matchAny(entry, patternsRe) {
+    return patternsRe.some((patternRe) => patternRe.test(entry));
+}
+/**
+ * This package only works with forward slashes as a path separator.
+ * Because of this, we cannot use the standard `path.normalize` method, because on Windows platform it will use of backslashes.
+ */
+function removeDuplicateSlashes(pattern) {
+    return pattern.replaceAll(DOUBLE_SLASH_RE, '/');
+}
+function partitionAbsoluteAndRelative(patterns) {
+    const absolute = [];
+    const relative = [];
+    for (const pattern of patterns) {
+        if (isAbsolute(pattern)) {
+            absolute.push(pattern);
+        }
+        else {
+            relative.push(pattern);
+        }
+    }
+    return [absolute, relative];
+}
+function isAbsolute(pattern) {
+    return path.isAbsolute(pattern);
+}

package/out/utils/stream.d.ts

@@ -0,0 +1,2 @@
+import type { Readable } from 'node:stream';
+export declare function merge(streams: Readable[]): NodeJS.ReadableStream;

package/out/utils/stream.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.merge = merge;
+// https://stackoverflow.com/a/39415662
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const merge2 = require("merge2");
+function merge(streams) {
+    const mergedStream = merge2(streams);
+    streams.forEach((stream) => {
+        stream.once('error', (error) => mergedStream.emit('error', error));
+    });
+    mergedStream.once('close', () => {
+        propagateCloseEventToSources(streams);
+    });
+    mergedStream.once('end', () => {
+        propagateCloseEventToSources(streams);
+    });
+    return mergedStream;
+}
+function propagateCloseEventToSources(streams) {
+    streams.forEach((stream) => stream.emit('close'));
+}

package/out/utils/string.d.ts

@@ -0,0 +1,8 @@
+export declare function isString(input: unknown): input is string;
+export declare function isEmpty(input: string): boolean;
+/**
+ * Flattens the underlying C structures of a concatenated JavaScript string.
+ *
+ * More details: https://github.com/davidmarkclements/flatstr
+ */
+export declare function flatHeavilyConcatenatedString(input: string): string;

package/out/utils/string.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isString = isString;
+exports.isEmpty = isEmpty;
+exports.flatHeavilyConcatenatedString = flatHeavilyConcatenatedString;
+function isString(input) {
+    return typeof input === 'string';
+}
+function isEmpty(input) {
+    return input === '';
+}
+/**
+ * Flattens the underlying C structures of a concatenated JavaScript string.
+ *
+ * More details: https://github.com/davidmarkclements/flatstr
+ */
+function flatHeavilyConcatenatedString(input) {
+    // @ts-expect-error Another solution can be `.trim`, but it changes the string.
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions, no-bitwise, unicorn/prefer-math-trunc
+    input | 0;
+    return input;
+}