@quilted/create 0.1.56 → 0.1.58

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/filters/error.esnext

@@ -0,0 +1,18 @@
+import { __exports as error } from '../../../../../../../../_virtual/error.esnext';
+import '../../utils/index.esnext';
+import { __exports as utils$1 } from '../../../../../../../../_virtual/index5.esnext';
+
+Object.defineProperty(error, "__esModule", { value: true });
+const utils = utils$1;
+class ErrorFilter {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getFilter() {
+        return (error) => this._isNonFatalError(error);
+    }
+    _isNonFatalError(error) {
+        return utils.errno.isEnoentCodeError(error) || this._settings.suppressErrors;
+    }
+}
+error.default = ErrorFilter;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/matchers/matcher.esnext

@@ -0,0 +1,53 @@
+import { __exports as matcher } from '../../../../../../../../_virtual/matcher.esnext';
+import '../../utils/index.esnext';
+import { __exports as utils$1 } from '../../../../../../../../_virtual/index5.esnext';
+
+Object.defineProperty(matcher, "__esModule", { value: true });
+const utils = utils$1;
+class Matcher {
+    constructor(_patterns, _settings, _micromatchOptions) {
+        this._patterns = _patterns;
+        this._settings = _settings;
+        this._micromatchOptions = _micromatchOptions;
+        this._storage = [];
+        this._fillStorage();
+    }
+    _fillStorage() {
+        /**
+         * The original pattern may include `{,*,**,a/*}`, which will lead to problems with matching (unresolved level).
+         * So, before expand patterns with brace expansion into separated patterns.
+         */
+        const patterns = utils.pattern.expandPatternsWithBraceExpansion(this._patterns);
+        for (const pattern of patterns) {
+            const segments = this._getPatternSegments(pattern);
+            const sections = this._splitSegmentsIntoSections(segments);
+            this._storage.push({
+                complete: sections.length <= 1,
+                pattern,
+                segments,
+                sections
+            });
+        }
+    }
+    _getPatternSegments(pattern) {
+        const parts = utils.pattern.getPatternParts(pattern, this._micromatchOptions);
+        return parts.map((part) => {
+            const dynamic = utils.pattern.isDynamicPattern(part, this._settings);
+            if (!dynamic) {
+                return {
+                    dynamic: false,
+                    pattern: part
+                };
+            }
+            return {
+                dynamic: true,
+                pattern: part,
+                patternRe: utils.pattern.makeRe(part, this._micromatchOptions)
+            };
+        });
+    }
+    _splitSegmentsIntoSections(segments) {
+        return utils.array.splitWhen(segments, (segment) => segment.dynamic && utils.pattern.hasGlobStar(segment.pattern));
+    }
+}
+matcher.default = Matcher;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/matchers/partial.esnext

@@ -0,0 +1,41 @@
+import { __exports as partial } from '../../../../../../../../_virtual/partial.esnext';
+import './matcher.esnext';
+import { __exports as matcher } from '../../../../../../../../_virtual/matcher.esnext';
+
+Object.defineProperty(partial, "__esModule", { value: true });
+const matcher_1 = matcher;
+class PartialMatcher extends matcher_1.default {
+    match(filepath) {
+        const parts = filepath.split('/');
+        const levels = parts.length;
+        const patterns = this._storage.filter((info) => !info.complete || info.segments.length > levels);
+        for (const pattern of patterns) {
+            const section = pattern.sections[0];
+            /**
+             * In this case, the pattern has a globstar and we must read all directories unconditionally,
+             * but only if the level has reached the end of the first group.
+             *
+             * fixtures/{a,b}/**
+             *  ^ true/false  ^ always true
+            */
+            if (!pattern.complete && levels > section.length) {
+                return true;
+            }
+            const match = parts.every((part, index) => {
+                const segment = pattern.segments[index];
+                if (segment.dynamic && segment.patternRe.test(part)) {
+                    return true;
+                }
+                if (!segment.dynamic && segment.pattern === part) {
+                    return true;
+                }
+                return false;
+            });
+            if (match) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+partial.default = PartialMatcher;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/provider.esnext

@@ -0,0 +1,58 @@
+import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+import path__default from 'node:path';
+import './filters/deep.esnext';
+import './filters/entry.esnext';
+import './filters/error.esnext';
+import './transformers/entry.esnext';
+import { __exports as deep } from '../../../../../../../_virtual/deep.esnext';
+import { __exports as entry } from '../../../../../../../_virtual/entry.esnext';
+import { __exports as error } from '../../../../../../../_virtual/error.esnext';
+import { __exports as entry$1 } from '../../../../../../../_virtual/entry2.esnext';
+
+Object.defineProperty(provider, "__esModule", { value: true });
+const path = path__default;
+const deep_1 = deep;
+const entry_1 = entry;
+const error_1 = error;
+const entry_2 = entry$1;
+class Provider {
+    constructor(_settings) {
+        this._settings = _settings;
+        this.errorFilter = new error_1.default(this._settings);
+        this.entryFilter = new entry_1.default(this._settings, this._getMicromatchOptions());
+        this.deepFilter = new deep_1.default(this._settings, this._getMicromatchOptions());
+        this.entryTransformer = new entry_2.default(this._settings);
+    }
+    _getRootDirectory(task) {
+        return path.resolve(this._settings.cwd, task.base);
+    }
+    _getReaderOptions(task) {
+        const basePath = task.base === '.' ? '' : task.base;
+        return {
+            basePath,
+            pathSegmentSeparator: '/',
+            concurrency: this._settings.concurrency,
+            deepFilter: this.deepFilter.getFilter(basePath, task.positive, task.negative),
+            entryFilter: this.entryFilter.getFilter(task.positive, task.negative),
+            errorFilter: this.errorFilter.getFilter(),
+            followSymbolicLinks: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            stats: this._settings.stats,
+            throwErrorOnBrokenSymbolicLink: this._settings.throwErrorOnBrokenSymbolicLink,
+            transform: this.entryTransformer.getTransformer()
+        };
+    }
+    _getMicromatchOptions() {
+        return {
+            dot: this._settings.dot,
+            matchBase: this._settings.baseNameMatch,
+            nobrace: !this._settings.braceExpansion,
+            nocase: !this._settings.caseSensitiveMatch,
+            noext: !this._settings.extglob,
+            noglobstar: !this._settings.globstar,
+            posix: true,
+            strictSlashes: false
+        };
+    }
+}
+provider.default = Provider;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/stream.esnext

@@ -0,0 +1,37 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream.esnext';
+import require$$0 from 'node:stream';
+import '../readers/stream.esnext';
+import './provider.esnext';
+import { __exports as stream$1 } from '../../../../../../../_virtual/stream2.esnext';
+import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1 = require$$0;
+const stream_2 = stream$1;
+const provider_1 = provider;
+class ProviderStream extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new stream_2.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const source = this.api(root, task, options);
+        const destination = new stream_1.Readable({ objectMode: true, read: () => { } });
+        source
+            .once('error', (error) => destination.emit('error', error))
+            .on('data', (entry) => destination.emit('data', options.transform(entry)))
+            .once('end', () => destination.emit('end'));
+        destination
+            .once('close', () => source.destroy());
+        return destination;
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+stream.default = ProviderStream;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/sync.esnext

@@ -0,0 +1,28 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync.esnext';
+import '../readers/sync.esnext';
+import './provider.esnext';
+import { __exports as sync$1 } from '../../../../../../../_virtual/sync2.esnext';
+import { __exports as provider } from '../../../../../../../_virtual/provider.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+const sync_1 = sync$1;
+const provider_1 = provider;
+class ProviderSync extends provider_1.default {
+    constructor() {
+        super(...arguments);
+        this._reader = new sync_1.default(this._settings);
+    }
+    read(task) {
+        const root = this._getRootDirectory(task);
+        const options = this._getReaderOptions(task);
+        const entries = this.api(root, task, options);
+        return entries.map(options.transform);
+    }
+    api(root, task, options) {
+        if (task.dynamic) {
+            return this._reader.dynamic(root, options);
+        }
+        return this._reader.static(task.patterns, options);
+    }
+}
+sync.default = ProviderSync;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/providers/transformers/entry.esnext

@@ -0,0 +1,29 @@
+import { __exports as entry } from '../../../../../../../../_virtual/entry2.esnext';
+import '../../utils/index.esnext';
+import { __exports as utils$1 } from '../../../../../../../../_virtual/index5.esnext';
+
+Object.defineProperty(entry, "__esModule", { value: true });
+const utils = utils$1;
+class EntryTransformer {
+    constructor(_settings) {
+        this._settings = _settings;
+    }
+    getTransformer() {
+        return (entry) => this._transform(entry);
+    }
+    _transform(entry) {
+        let filepath = entry.path;
+        if (this._settings.absolute) {
+            filepath = utils.path.makeAbsolute(this._settings.cwd, filepath);
+            filepath = utils.path.unixify(filepath);
+        }
+        if (this._settings.markDirectories && entry.dirent.isDirectory()) {
+            filepath += '/';
+        }
+        if (!this._settings.objectMode) {
+            return filepath;
+        }
+        return Object.assign(Object.assign({}, entry), { path: filepath });
+    }
+}
+entry.default = EntryTransformer;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/readers/reader.esnext

@@ -0,0 +1,39 @@
+import { __exports as reader } from '../../../../../../../_virtual/reader.esnext';
+import path__default from 'node:path';
+import '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import '../utils/index.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index7.esnext';
+import { __exports as utils$1 } from '../../../../../../../_virtual/index5.esnext';
+
+Object.defineProperty(reader, "__esModule", { value: true });
+const path = path__default;
+const fsStat = out;
+const utils = utils$1;
+class Reader {
+    constructor(_settings) {
+        this._settings = _settings;
+        this._fsStatSettings = new fsStat.Settings({
+            followSymbolicLink: this._settings.followSymbolicLinks,
+            fs: this._settings.fs,
+            throwErrorOnBrokenSymbolicLink: this._settings.followSymbolicLinks
+        });
+    }
+    _getFullEntryPath(filepath) {
+        return path.resolve(this._settings.cwd, filepath);
+    }
+    _makeEntry(stats, pattern) {
+        const entry = {
+            name: pattern,
+            path: pattern,
+            dirent: utils.fs.createDirentFromStats(pattern, stats)
+        };
+        if (this._settings.stats) {
+            entry.stats = stats;
+        }
+        return entry;
+    }
+    _isFatalError(error) {
+        return !utils.errno.isEnoentCodeError(error) && !this._settings.suppressErrors;
+    }
+}
+reader.default = Reader;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/readers/stream.esnext

@@ -0,0 +1,63 @@
+import { __exports as stream } from '../../../../../../../_virtual/stream2.esnext';
+import require$$0 from 'node:stream';
+import '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext';
+import './reader.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index7.esnext';
+import { __exports as out$1 } from '../../../../../../../_virtual/index8.esnext';
+import { __exports as reader } from '../../../../../../../_virtual/reader.esnext';
+
+Object.defineProperty(stream, "__esModule", { value: true });
+const stream_1 = require$$0;
+const fsStat = out;
+const fsWalk = out$1;
+const reader_1 = reader;
+class ReaderStream extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkStream = fsWalk.walkStream;
+        this._stat = fsStat.stat;
+    }
+    dynamic(root, options) {
+        return this._walkStream(root, options);
+    }
+    static(patterns, options) {
+        const filepaths = patterns.map(this._getFullEntryPath, this);
+        const stream = new stream_1.PassThrough({ objectMode: true });
+        stream._write = (index, _enc, done) => {
+            return this._getEntry(filepaths[index], patterns[index], options)
+                .then((entry) => {
+                if (entry !== null && options.entryFilter(entry)) {
+                    stream.push(entry);
+                }
+                if (index === filepaths.length - 1) {
+                    stream.end();
+                }
+                done();
+            })
+                .catch(done);
+        };
+        for (let i = 0; i < filepaths.length; i++) {
+            stream.write(i);
+        }
+        return stream;
+    }
+    _getEntry(filepath, pattern, options) {
+        return this._getStat(filepath)
+            .then((stats) => this._makeEntry(stats, pattern))
+            .catch((error) => {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        });
+    }
+    _getStat(filepath) {
+        return new Promise((resolve, reject) => {
+            this._stat(filepath, this._fsStatSettings, (error, stats) => {
+                return error === null ? resolve(stats) : reject(error);
+            });
+        });
+    }
+}
+stream.default = ReaderStream;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/readers/sync.esnext

@@ -0,0 +1,50 @@
+import { __exports as sync } from '../../../../../../../_virtual/sync2.esnext';
+import '../../../../../@nodelib_fs.stat@2.0.5/node_modules/@nodelib/fs.stat/out/index.esnext';
+import '../../../../../@nodelib_fs.walk@1.2.8/node_modules/@nodelib/fs.walk/out/index.esnext';
+import './reader.esnext';
+import { __exports as out } from '../../../../../../../_virtual/index7.esnext';
+import { __exports as out$1 } from '../../../../../../../_virtual/index8.esnext';
+import { __exports as reader } from '../../../../../../../_virtual/reader.esnext';
+
+Object.defineProperty(sync, "__esModule", { value: true });
+const fsStat = out;
+const fsWalk = out$1;
+const reader_1 = reader;
+class ReaderSync extends reader_1.default {
+    constructor() {
+        super(...arguments);
+        this._walkSync = fsWalk.walkSync;
+        this._statSync = fsStat.statSync;
+    }
+    dynamic(root, options) {
+        return this._walkSync(root, options);
+    }
+    static(patterns, options) {
+        const entries = [];
+        for (const pattern of patterns) {
+            const filepath = this._getFullEntryPath(pattern);
+            const entry = this._getEntry(filepath, pattern, options);
+            if (entry === null || !options.entryFilter(entry)) {
+                continue;
+            }
+            entries.push(entry);
+        }
+        return entries;
+    }
+    _getEntry(filepath, pattern, options) {
+        try {
+            const stats = this._getStat(filepath);
+            return this._makeEntry(stats, pattern);
+        }
+        catch (error) {
+            if (options.errorFilter(error)) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    _getStat(filepath) {
+        return this._statSync(filepath, this._fsStatSettings);
+    }
+}
+sync.default = ReaderSync;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/settings.esnext

@@ -0,0 +1,62 @@
+import { __exports as settings } from '../../../../../../_virtual/settings.esnext';
+import fs__default from 'node:fs';
+import require$$2 from 'node:os';
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.DEFAULT_FILE_SYSTEM_ADAPTER = void 0;
+	const fs = fs__default;
+	const os = require$$2;
+	/**
+	 * The `os.cpus` method can return zero. We expect the number of cores to be greater than zero.
+	 * https://github.com/nodejs/node/blob/7faeddf23a98c53896f8b574a6e66589e8fb1eb8/lib/os.js#L106-L107
+	 */
+	const CPU_COUNT = Math.max(os.cpus().length, 1);
+	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 {
+	    constructor(_options = {}) {
+	        this._options = _options;
+	        this.absolute = this._getValue(this._options.absolute, false);
+	        this.baseNameMatch = this._getValue(this._options.baseNameMatch, false);
+	        this.braceExpansion = this._getValue(this._options.braceExpansion, true);
+	        this.caseSensitiveMatch = this._getValue(this._options.caseSensitiveMatch, true);
+	        this.concurrency = this._getValue(this._options.concurrency, CPU_COUNT);
+	        this.cwd = this._getValue(this._options.cwd, process.cwd());
+	        this.deep = this._getValue(this._options.deep, Infinity);
+	        this.dot = this._getValue(this._options.dot, false);
+	        this.extglob = this._getValue(this._options.extglob, true);
+	        this.followSymbolicLinks = this._getValue(this._options.followSymbolicLinks, true);
+	        this.fs = this._getFileSystemMethods(this._options.fs);
+	        this.globstar = this._getValue(this._options.globstar, true);
+	        this.ignore = this._getValue(this._options.ignore, []);
+	        this.markDirectories = this._getValue(this._options.markDirectories, false);
+	        this.objectMode = this._getValue(this._options.objectMode, false);
+	        this.onlyDirectories = this._getValue(this._options.onlyDirectories, false);
+	        this.onlyFiles = this._getValue(this._options.onlyFiles, true);
+	        this.stats = this._getValue(this._options.stats, false);
+	        this.suppressErrors = this._getValue(this._options.suppressErrors, false);
+	        this.throwErrorOnBrokenSymbolicLink = this._getValue(this._options.throwErrorOnBrokenSymbolicLink, false);
+	        this.unique = this._getValue(this._options.unique, true);
+	        if (this.onlyDirectories) {
+	            this.onlyFiles = false;
+	        }
+	        if (this.stats) {
+	            this.objectMode = true;
+	        }
+	    }
+	    _getValue(option, value) {
+	        return option === undefined ? value : option;
+	    }
+	    _getFileSystemMethods(methods = {}) {
+	        return Object.assign(Object.assign({}, exports.DEFAULT_FILE_SYSTEM_ADAPTER), methods);
+	    }
+	}
+	exports.default = Settings;
+} (settings));

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/utils/array.esnext

@@ -0,0 +1,24 @@
+import { __exports as array } from '../../../../../../../_virtual/array.esnext';
+export { __exports as default } from '../../../../../../../_virtual/array.esnext';
+
+Object.defineProperty(array, "__esModule", { value: true });
+array.splitWhen = array.flatten = void 0;
+function flatten(items) {
+    return items.reduce((collection, item) => [].concat(collection, item), []);
+}
+array.flatten = flatten;
+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;
+}
+array.splitWhen = splitWhen;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/utils/errno.esnext

@@ -0,0 +1,9 @@
+import { __exports as errno } from '../../../../../../../_virtual/errno.esnext';
+export { __exports as default } from '../../../../../../../_virtual/errno.esnext';
+
+Object.defineProperty(errno, "__esModule", { value: true });
+errno.isEnoentCodeError = void 0;
+function isEnoentCodeError(error) {
+    return error.code === 'ENOENT';
+}
+errno.isEnoentCodeError = isEnoentCodeError;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/utils/fs.esnext

@@ -0,0 +1,21 @@
+import { __exports as fs } from '../../../../../../../_virtual/fs.esnext';
+export { __exports as default } from '../../../../../../../_virtual/fs.esnext';
+
+Object.defineProperty(fs, "__esModule", { value: true });
+fs.createDirentFromStats = void 0;
+class DirentFromStats {
+    constructor(name, stats) {
+        this.name = name;
+        this.isBlockDevice = stats.isBlockDevice.bind(stats);
+        this.isCharacterDevice = stats.isCharacterDevice.bind(stats);
+        this.isDirectory = stats.isDirectory.bind(stats);
+        this.isFIFO = stats.isFIFO.bind(stats);
+        this.isFile = stats.isFile.bind(stats);
+        this.isSocket = stats.isSocket.bind(stats);
+        this.isSymbolicLink = stats.isSymbolicLink.bind(stats);
+    }
+}
+function createDirentFromStats(name, stats) {
+    return new DirentFromStats(name, stats);
+}
+fs.createDirentFromStats = createDirentFromStats;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/utils/index.esnext

@@ -0,0 +1,33 @@
+import { __exports as utils } from '../../../../../../../_virtual/index5.esnext';
+export { __exports as default } from '../../../../../../../_virtual/index5.esnext';
+import './array.esnext';
+import './errno.esnext';
+import './fs.esnext';
+import './path.esnext';
+import './pattern.esnext';
+import './stream.esnext';
+import './string.esnext';
+import { __exports as array$1 } from '../../../../../../../_virtual/array.esnext';
+import { __exports as errno$1 } from '../../../../../../../_virtual/errno.esnext';
+import { __exports as fs$1 } from '../../../../../../../_virtual/fs.esnext';
+import { __exports as path$1 } from '../../../../../../../_virtual/path.esnext';
+import { __exports as pattern$1 } from '../../../../../../../_virtual/pattern.esnext';
+import { __exports as stream$1 } from '../../../../../../../_virtual/stream3.esnext';
+import { __exports as string$1 } from '../../../../../../../_virtual/string2.esnext';
+
+Object.defineProperty(utils, "__esModule", { value: true });
+utils.string = utils.stream = utils.pattern = utils.path = utils.fs = utils.errno = utils.array = void 0;
+const array = array$1;
+utils.array = array;
+const errno = errno$1;
+utils.errno = errno;
+const fs = fs$1;
+utils.fs = fs;
+const path = path$1;
+utils.path = path;
+const pattern = pattern$1;
+utils.pattern = pattern;
+const stream = stream$1;
+utils.stream = stream;
+const string = string$1;
+utils.string = string;

package/build/esnext/node_modules/.pnpm/fast-glob@3.2.11/node_modules/fast-glob/out/utils/path.esnext

@@ -0,0 +1,36 @@
+import { __exports as path$1 } from '../../../../../../../_virtual/path.esnext';
+export { __exports as default } from '../../../../../../../_virtual/path.esnext';
+import path__default from 'node:path';
+
+Object.defineProperty(path$1, "__esModule", { value: true });
+path$1.removeLeadingDotSegment = path$1.escape = path$1.makeAbsolute = path$1.unixify = void 0;
+const path = path__default;
+const LEADING_DOT_SEGMENT_CHARACTERS_COUNT = 2; // ./ or .\\
+const UNESCAPED_GLOB_SYMBOLS_RE = /(\\?)([()*?[\]{|}]|^!|[!+@](?=\())/g;
+/**
+ * Designed to work only with simple paths: `dir\\file`.
+ */
+function unixify(filepath) {
+    return filepath.replace(/\\/g, '/');
+}
+path$1.unixify = unixify;
+function makeAbsolute(cwd, filepath) {
+    return path.resolve(cwd, filepath);
+}
+path$1.makeAbsolute = makeAbsolute;
+function escape(pattern) {
+    return pattern.replace(UNESCAPED_GLOB_SYMBOLS_RE, '\\$2');
+}
+path$1.escape = escape;
+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;
+}
+path$1.removeLeadingDotSegment = removeLeadingDotSegment;