cspell 9.1.2 → 9.1.5

package/dist/esm/util/configFileHelper.d.ts

@@ -1,15 +0,0 @@
-import type { CSpellUserSettings } from 'cspell-lib';
-import { CSpellConfigFile } from '../options.js';
-export interface ConfigInfo {
-    source: string;
-    config: CSpellUserSettings;
-}
-export interface FileConfigInfo {
-    configInfo: ConfigInfo;
-    filename: string;
-    text: string;
-    languageIds: string[];
-}
-export declare function readConfig(configFile: string | CSpellConfigFile | undefined, root: string | undefined, stopConfigSearchAt?: (URL | string)[] | undefined): Promise<ConfigInfo>;
-export declare function readConfigFile(filename: string | URL): Promise<CSpellConfigFile>;
-//# sourceMappingURL=configFileHelper.d.ts.map

package/dist/esm/util/configFileHelper.js

@@ -1,43 +0,0 @@
-import { toFilePathOrHref } from '@cspell/url';
-import * as cspell from 'cspell-lib';
-import { environmentKeys, getEnvironmentVariable } from '../environment.js';
-import { filenameToUrl } from './fileHelper.js';
-export async function readConfig(configFile, root, stopConfigSearchAt) {
-    configFile ??= getEnvironmentVariable(environmentKeys.CSPELL_CONFIG_PATH);
-    if (configFile) {
-        const cfgFile = typeof configFile === 'string' ? await readConfigHandleError(configFile) : configFile;
-        return configFileToConfigInfo(cfgFile);
-    }
-    const config = await cspell.searchForConfig(root, { stopSearchAt: stopConfigSearchAt });
-    const defaultConfigFile = getEnvironmentVariable(environmentKeys.CSPELL_DEFAULT_CONFIG_PATH);
-    if (!config && defaultConfigFile) {
-        const cfgFile = await readConfigFile(defaultConfigFile).catch(() => undefined);
-        if (cfgFile) {
-            return configFileToConfigInfo(cfgFile);
-        }
-    }
-    return { source: config?.__importRef?.filename || 'None found', config: config || {} };
-}
-async function configFileToConfigInfo(cfgFile) {
-    const config = await cspell.resolveConfigFileImports(cfgFile);
-    const source = toFilePathOrHref(cfgFile.url);
-    return { source, config };
-}
-export function readConfigFile(filename) {
-    return cspell.readConfigFile(filename);
-}
-async function readConfigHandleError(filename) {
-    try {
-        return await readConfigFile(filename);
-    }
-    catch (e) {
-        const settings = {
-            __importRef: {
-                filename: filename.toString(),
-                error: e,
-            },
-        };
-        return { url: filenameToUrl(filename), settings };
-    }
-}
-//# sourceMappingURL=configFileHelper.js.map

package/dist/esm/util/constants.d.ts

@@ -1,6 +0,0 @@
-export declare const UTF8: "utf8";
-export declare const STDIN: "stdin";
-export declare const STDINProtocol: "stdin:";
-export declare const STDINUrlPrefix: "stdin://";
-export declare const FileUrlPrefix: "file://";
-//# sourceMappingURL=constants.d.ts.map

package/dist/esm/util/constants.js

@@ -1,6 +0,0 @@
-export const UTF8 = 'utf8';
-export const STDIN = 'stdin';
-export const STDINProtocol = 'stdin:';
-export const STDINUrlPrefix = 'stdin://';
-export const FileUrlPrefix = 'file://';
-//# sourceMappingURL=constants.js.map

package/dist/esm/util/errors.d.ts

@@ -1,24 +0,0 @@
-export declare class CheckFailed extends Error {
-    readonly exitCode: number;
-    constructor(message: string, exitCode?: number);
-}
-export declare class ApplicationError extends Error {
-    readonly exitCode: number;
-    readonly cause?: Error | undefined;
-    constructor(message: string, exitCode?: number, cause?: Error | undefined);
-}
-export declare class IOError extends ApplicationError {
-    readonly cause: NodeError;
-    constructor(message: string, cause: NodeError);
-    get code(): string | undefined;
-    isNotFound(): boolean;
-}
-export declare function toError(e: unknown): NodeError;
-export declare function isError(e: unknown): e is NodeError;
-export declare function isErrorLike(e: unknown): e is NodeError;
-export declare function toApplicationError(e: unknown, message?: string): ApplicationError;
-export interface NodeError extends Error {
-    code?: string;
-    toString?: () => string;
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/esm/util/errors.js

@@ -1,60 +0,0 @@
-import { format } from 'node:util';
-export class CheckFailed extends Error {
-    exitCode;
-    constructor(message, exitCode = 1) {
-        super(message);
-        this.exitCode = exitCode;
-    }
-}
-export class ApplicationError extends Error {
-    exitCode;
-    cause;
-    constructor(message, exitCode = 1, cause) {
-        super(message);
-        this.exitCode = exitCode;
-        this.cause = cause;
-    }
-}
-export class IOError extends ApplicationError {
-    cause;
-    constructor(message, cause) {
-        super(message, undefined, cause);
-        this.cause = cause;
-    }
-    get code() {
-        return this.cause.code;
-    }
-    isNotFound() {
-        return this.cause.code === 'ENOENT';
-    }
-}
-export function toError(e) {
-    if (isError(e))
-        return e;
-    if (isErrorLike(e)) {
-        const ex = new Error(e.message, { cause: e });
-        if (e.code !== undefined)
-            ex.code = e.code;
-        return ex;
-    }
-    const message = format(e);
-    return new Error(message);
-}
-export function isError(e) {
-    return e instanceof Error;
-}
-export function isErrorLike(e) {
-    if (e instanceof Error)
-        return true;
-    if (!e || typeof e !== 'object')
-        return false;
-    const ex = e;
-    return typeof ex.message === 'string';
-}
-export function toApplicationError(e, message) {
-    if (e instanceof ApplicationError && !message)
-        return e;
-    const err = toError(e);
-    return new ApplicationError(message ?? err.message, undefined, err);
-}
-//# sourceMappingURL=errors.js.map

package/dist/esm/util/extractContext.d.ts

@@ -1,5 +0,0 @@
-import type { TextDocumentOffset, TextOffset } from '@cspell/cspell-types';
-export declare function fixOffsetToBeginningOfChar(text: string, offset: number): number;
-export declare function lineContext(lineText: string, start: number, end: number, contextRange: number): TextOffset;
-export declare function extractContext(tdo: Pick<TextDocumentOffset, 'line' | 'offset' | 'text'>, contextRange: number): TextOffset;
-//# sourceMappingURL=extractContext.d.ts.map

package/dist/esm/util/extractContext.js

@@ -1,75 +0,0 @@
-export function fixOffsetToBeginningOfChar(text, offset) {
-    const code = text.charCodeAt(offset) || 0;
-    return offset + ((code & 0xfc00) === 0xdc00 ? 1 : 0);
-}
-function prefCharIndex(text, offset, count = 1) {
-    if (offset - count < 0)
-        return 0;
-    for (; count > 0 && offset > 0; count--) {
-        let code = text.charCodeAt(--offset) || 0;
-        if (code === 0xfe0f) {
-            // Remove zero-width joiner
-            code = text.charCodeAt(--offset) || 0;
-        }
-        offset -= (code & 0xfc00) === 0xdc00 ? 1 : 0;
-    }
-    return offset < 0 ? 0 : offset;
-}
-function nextCharIndex(text, offset, count = 1) {
-    if (offset + count >= text.length)
-        return text.length;
-    for (; count > 0 && offset < text.length; count--) {
-        const code = text.charCodeAt(offset++) || 0;
-        offset += (code & 0xfc00) === 0xd800 ? 1 : 0;
-        if (text.charCodeAt(offset) === 0xfe0f) {
-            // Skip zero-width joiner
-            offset++;
-        }
-    }
-    return offset > text.length ? text.length : offset;
-}
-export function lineContext(lineText, start, end, contextRange) {
-    let left = prefCharIndex(lineText, start, contextRange);
-    let right = nextCharIndex(lineText, end, contextRange);
-    const isLetter = /^\p{L}$/u;
-    const isMark = /^\p{M}$/u;
-    for (let n = contextRange / 2; n > 0 && left > 0; n--, left--) {
-        const c = lineText[left - 1];
-        if (isMark.test(c)) {
-            if (!isLetter.test(lineText[left - 2])) {
-                break;
-            }
-            left--;
-            continue;
-        }
-        if (!isLetter.test(lineText[left - 1])) {
-            break;
-        }
-    }
-    for (let n = contextRange / 2; n > 0 && right < lineText.length; n--, right++) {
-        if (!isLetter.test(lineText[right])) {
-            break;
-        }
-        if (isMark.test(lineText[right + 1])) {
-            right++;
-        }
-    }
-    left = left < 0 ? 0 : left;
-    const t0 = lineText.slice(left, right);
-    const tLeft = t0.trimStart();
-    left = Math.min(left + t0.length - tLeft.length, start);
-    const text = tLeft.trimEnd();
-    const context = {
-        text,
-        offset: left,
-    };
-    return context;
-}
-export function extractContext(tdo, contextRange) {
-    const { line, offset, text } = tdo;
-    const start = offset - line.offset;
-    const context = lineContext(line.text, start, start + text.length, contextRange);
-    context.offset += line.offset;
-    return context;
-}
-//# sourceMappingURL=extractContext.js.map

package/dist/esm/util/fileHelper.d.ts

@@ -1,44 +0,0 @@
-import type { BufferEncoding } from 'cspell-io';
-import type { Document } from 'cspell-lib';
-import * as cspell from 'cspell-lib';
-import type { GlobOptions } from './glob.js';
-export interface FileInfo {
-    filename: string;
-    text?: string;
-    errorCode?: string;
-}
-export type Perf = cspell.SpellCheckFilePerf;
-export declare function fileInfoToDocument(fileInfo: FileInfo, languageId: string | undefined, locale: string | undefined): Document;
-export declare function filenameToUrl(filename: string | URL, cwd?: string): URL;
-export declare function filenameToUri(filename: string, cwd?: string): URL;
-export declare function isBinaryFile(filename: string, cwd?: string): boolean;
-export interface ReadFileInfoResult extends FileInfo {
-    text: string;
-}
-export declare function resolveFilename(filename: string, cwd?: string): string;
-export declare function readFileInfo(filename: string, encoding?: BufferEncoding, handleNotFound?: boolean): Promise<ReadFileInfoResult>;
-export declare function readFile(filename: string, encoding?: BufferEncoding): Promise<string>;
-/**
- * Looks for matching glob patterns or stdin
- * @param globPatterns patterns or stdin
- */
-export declare function findFiles(globPatterns: string[], options: GlobOptions): Promise<string[]>;
-/**
- * Read
- * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
- *   file will be resolved relative to the containing file.
- * @returns - a list of files to be processed.
- */
-export declare function readFileListFiles(listFiles: string[]): AsyncIterable<string>;
-/**
- * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
- * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
- *   file will be resolved relative to the containing file.
- * @returns - a list of files to be processed.
- */
-export declare function readFileListFile(listFile: string): Promise<string[]>;
-export declare function isFile(filename: string): Promise<boolean>;
-export declare function isDir(filename: string): Promise<boolean>;
-export declare function isNotDir(filename: string): Promise<boolean>;
-export declare function relativeToCwd(filename: string | URL, cwd?: string | URL): string;
-//# sourceMappingURL=fileHelper.d.ts.map

package/dist/esm/util/fileHelper.js

@@ -1,165 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import * as path from 'node:path';
-import streamConsumers from 'node:stream/consumers';
-import { fileURLToPath } from 'node:url';
-import { toFileDirURL, toFilePathOrHref, toFileURL, urlRelative } from '@cspell/url';
-import { readFileText as cioReadFile, toURL } from 'cspell-io';
-import { fileToDocument, isBinaryFile as isUriBinaryFile } from 'cspell-lib';
-import { asyncAwait, asyncFlatten, asyncMap, asyncPipe, mergeAsyncIterables } from './async.js';
-import { FileUrlPrefix, STDIN, STDINProtocol, STDINUrlPrefix, UTF8 } from './constants.js';
-import { IOError, toApplicationError, toError } from './errors.js';
-import { globP } from './glob.js';
-import { readStdin } from './stdin.js';
-import { isStdinUrl, resolveStdinUrl } from './stdinUrl.js';
-import { clean } from './util.js';
-export function fileInfoToDocument(fileInfo, languageId, locale) {
-    const { filename, text } = fileInfo;
-    languageId = languageId || undefined;
-    locale = locale || undefined;
-    const uri = filenameToUrl(filename);
-    if (uri.href.startsWith(STDINProtocol)) {
-        return clean({
-            uri: uri.href,
-            text,
-            languageId,
-            locale,
-        });
-    }
-    return fileToDocument(uri.href, text, languageId, locale);
-}
-export function filenameToUrl(filename, cwd = '.') {
-    if (filename instanceof URL)
-        return filename;
-    const cwdURL = toFileDirURL(cwd);
-    if (filename === STDIN)
-        return new URL('stdin:///');
-    if (isStdinUrl(filename)) {
-        return new URL(resolveStdinUrl(filename, cwd));
-    }
-    return toFileURL(filename, cwdURL);
-}
-export function filenameToUri(filename, cwd) {
-    return toURL(filenameToUrl(filename, cwd));
-}
-export function isBinaryFile(filename, cwd) {
-    const uri = filenameToUri(filename, cwd);
-    if (uri.protocol.startsWith('stdin'))
-        return false;
-    return isUriBinaryFile(uri);
-}
-export function resolveFilename(filename, cwd) {
-    cwd = cwd || process.cwd();
-    if (filename === STDIN)
-        return STDINUrlPrefix;
-    if (filename.startsWith(FileUrlPrefix)) {
-        const url = new URL(filename.slice(FileUrlPrefix.length), toFileDirURL(cwd));
-        return fileURLToPath(url);
-    }
-    if (isStdinUrl(filename)) {
-        return resolveStdinUrl(filename, cwd);
-    }
-    return path.resolve(cwd, filename);
-}
-export function readFileInfo(filename, encoding = UTF8, handleNotFound = false) {
-    filename = resolveFilename(filename);
-    const pText = filename.startsWith(STDINProtocol)
-        ? streamConsumers.text(process.stdin)
-        : cioReadFile(filename, encoding);
-    return pText.then((text) => ({ text, filename }), (e) => {
-        const error = toError(e);
-        return handleNotFound && error.code === 'EISDIR'
-            ? Promise.resolve({ text: '', filename, errorCode: error.code })
-            : handleNotFound && error.code === 'ENOENT'
-                ? Promise.resolve({ text: '', filename, errorCode: error.code })
-                : Promise.reject(new IOError(`Error reading file: "${filename}"`, error));
-    });
-}
-export function readFile(filename, encoding = UTF8) {
-    return readFileInfo(filename, encoding).then((info) => info.text);
-}
-/**
- * Looks for matching glob patterns or stdin
- * @param globPatterns patterns or stdin
- */
-export async function findFiles(globPatterns, options) {
-    const stdin = [];
-    const globPats = globPatterns.filter((filename) => !isStdin(filename) && !filename.startsWith(FileUrlPrefix) ? true : (stdin.push(filename), false));
-    const globResults = globPats.length ? await globP(globPats, options) : [];
-    const cwd = options.cwd || process.cwd();
-    return [...stdin, ...globResults].map((filename) => resolveFilename(filename, cwd));
-}
-const resolveFilenames = asyncMap(resolveFilename);
-/**
- * Read
- * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
- *   file will be resolved relative to the containing file.
- * @returns - a list of files to be processed.
- */
-export function readFileListFiles(listFiles) {
-    let useStdin = false;
-    const files = listFiles.filter((file) => {
-        const isStdin = file === 'stdin';
-        useStdin = useStdin || isStdin;
-        return !isStdin;
-    });
-    const found = asyncPipe(files, asyncMap((file) => readFileListFile(file)), asyncAwait(), asyncFlatten());
-    // Move `stdin` to the end.
-    const stdin = useStdin ? readStdin() : [];
-    return asyncPipe(mergeAsyncIterables(found, stdin), resolveFilenames);
-}
-/**
- * Read a `listFile` and return the containing file paths resolved relative to the `listFile`.
- * @param listFiles - array of file paths to read that will contain a list of files. Paths contained in each
- *   file will be resolved relative to the containing file.
- * @returns - a list of files to be processed.
- */
-export async function readFileListFile(listFile) {
-    try {
-        const relTo = path.resolve(path.dirname(listFile));
-        const content = await readFile(listFile);
-        const lines = content
-            .split('\n')
-            .map((a) => a.trim())
-            .filter((a) => !!a)
-            .map((file) => path.resolve(relTo, file));
-        return lines;
-    }
-    catch (err) {
-        throw toApplicationError(err, `Error reading file list from: "${listFile}"`);
-    }
-}
-function isStdin(filename) {
-    return filename === STDIN || isStdinUrl(filename);
-}
-export async function isFile(filename) {
-    if (isStdin(filename))
-        return true;
-    try {
-        const stat = await fsp.stat(filename);
-        return stat.isFile();
-    }
-    catch {
-        return false;
-    }
-}
-export async function isDir(filename) {
-    try {
-        const stat = await fsp.stat(filename);
-        return stat.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-export function isNotDir(filename) {
-    return isDir(filename).then((a) => !a);
-}
-export function relativeToCwd(filename, cwd = process.cwd()) {
-    const urlCwd = toFileDirURL(cwd);
-    const url = toFileURL(filename, urlCwd);
-    const rel = urlRelative(urlCwd, url);
-    if (rel.startsWith('..'))
-        return toFilePathOrHref(url);
-    return rel;
-}
-//# sourceMappingURL=fileHelper.js.map

package/dist/esm/util/glob.d.ts

@@ -1,45 +0,0 @@
-import type { CSpellUserSettings, Glob } from '@cspell/cspell-types';
-import type { GlobPatternWithRoot } from 'cspell-glob';
-import { GlobMatcher } from 'cspell-glob';
-/**
- * This is a subset of IOptions from 'glob'.
- */
-export interface GlobOptions {
-    cwd?: string | undefined;
-    root?: string | undefined;
-    dot?: boolean | undefined;
-    nodir?: boolean | undefined;
-    ignore?: string | Array<string> | undefined;
-}
-/**
- *
- * @param pattern - glob patterns and NOT file paths. It can be a file path turned into a glob.
- * @param options - search options.
- */
-export declare function globP(pattern: string | string[], options?: GlobOptions): Promise<string[]>;
-export declare function calcGlobs(commandLineExclude: string[] | undefined): {
-    globs: string[];
-    source: string;
-};
-export interface GlobSrcInfo {
-    matcher: GlobMatcher;
-    source: string;
-}
-interface ExtractPatternResult {
-    glob: GlobPatternWithRoot;
-    source: string;
-}
-export declare function extractPatterns(globs: GlobSrcInfo[]): ExtractPatternResult[];
-export declare function calcExcludeGlobInfo(root: string, commandLineExclude: string[] | string | undefined): GlobSrcInfo[];
-export declare function extractGlobExcludesFromConfig(root: string, source: string, config: CSpellUserSettings): GlobSrcInfo[];
-/**
- * Build GlobMatcher from command line or config file globs.
- * @param globs Glob patterns or file paths
- * @param root - directory to use as the root
- */
-export declare function buildGlobMatcher(globs: Glob[], root: string, isExclude: boolean): GlobMatcher;
-export declare function extractGlobsFromMatcher(globMatcher: GlobMatcher): string[];
-export declare function normalizeGlobsToRoot(globs: Glob[], root: string, isExclude: boolean): string[];
-export declare function normalizeFileOrGlobsToRoot(globs: Glob[], root: string): Promise<string[]>;
-export {};
-//# sourceMappingURL=glob.d.ts.map

package/dist/esm/util/glob.js

@@ -1,147 +0,0 @@
-import { promises as fs } from 'node:fs';
-import * as path from 'node:path';
-import { posix } from 'node:path';
-import { fileOrGlobToGlob, GlobMatcher, workaroundPicomatchBug } from 'cspell-glob';
-import { glob as tinyGlob } from 'tinyglobby';
-import { clean } from './util.js';
-const defaultExcludeGlobs = ['node_modules/**'];
-/**
- *
- * @param pattern - glob patterns and NOT file paths. It can be a file path turned into a glob.
- * @param options - search options.
- */
-export async function globP(pattern, options) {
-    const cwd = options?.root || options?.cwd || process.cwd();
-    const ignoreRaw = typeof options?.ignore === 'string' ? [options.ignore] : options?.ignore;
-    const ignore = ignoreRaw?.filter((g) => !g.startsWith('../'));
-    const onlyFiles = options?.nodir;
-    const dot = options?.dot;
-    const patterns = typeof pattern === 'string' ? [pattern] : pattern;
-    const useOptions = clean({
-        cwd,
-        onlyFiles,
-        dot,
-        ignore,
-        absolute: true,
-        followSymbolicLinks: false,
-        expandDirectories: false,
-        // debug: true,
-    });
-    const compare = new Intl.Collator('en').compare;
-    const absolutePaths = (await glob(patterns, useOptions)).sort(compare);
-    const relativePaths = absolutePaths.map((absFilename) => path.relative(cwd, absFilename));
-    return relativePaths;
-}
-export function calcGlobs(commandLineExclude) {
-    const globs = new Set((commandLineExclude || []).flatMap((glob) => glob.split(/(?<!\\)\s+/g)).map((g) => g.replaceAll('\\ ', ' ')));
-    const commandLineExcludes = {
-        globs: [...globs],
-        source: 'arguments',
-    };
-    const defaultExcludes = {
-        globs: defaultExcludeGlobs,
-        source: 'default',
-    };
-    return commandLineExcludes.globs.length ? commandLineExcludes : defaultExcludes;
-}
-export function extractPatterns(globs) {
-    const r = globs.reduce((info, g) => {
-        const source = g.source;
-        const patterns = g.matcher.patternsNormalizedToRoot;
-        return [...info, ...patterns.map((glob) => ({ glob, source }))];
-    }, []);
-    return r;
-}
-export function calcExcludeGlobInfo(root, commandLineExclude) {
-    commandLineExclude = typeof commandLineExclude === 'string' ? [commandLineExclude] : commandLineExclude;
-    const choice = calcGlobs(commandLineExclude);
-    const matcher = new GlobMatcher(choice.globs, { root, dot: true });
-    return [
-        {
-            matcher,
-            source: choice.source,
-        },
-    ];
-}
-export function extractGlobExcludesFromConfig(root, source, config) {
-    if (!config.ignorePaths || !config.ignorePaths.length) {
-        return [];
-    }
-    const matcher = new GlobMatcher(config.ignorePaths, { root, dot: true });
-    return [{ source, matcher }];
-}
-/**
- * Build GlobMatcher from command line or config file globs.
- * @param globs Glob patterns or file paths
- * @param root - directory to use as the root
- */
-export function buildGlobMatcher(globs, root, isExclude) {
-    const withRoots = globs.map((g) => {
-        const source = typeof g === 'string' ? 'command line' : undefined;
-        return { source, ...fileOrGlobToGlob(g, root) };
-    });
-    return new GlobMatcher(withRoots, { root, mode: isExclude ? 'exclude' : 'include' });
-}
-export function extractGlobsFromMatcher(globMatcher) {
-    return globMatcher.patternsNormalizedToRoot.map((g) => g.glob);
-}
-export function normalizeGlobsToRoot(globs, root, isExclude) {
-    const urls = globs.filter((g) => typeof g === 'string' && isPossibleUrlRegExp.test(g));
-    const onlyGlobs = globs.filter((g) => typeof g !== 'string' || !isPossibleUrlRegExp.test(g));
-    return [urls, extractGlobsFromMatcher(buildGlobMatcher(onlyGlobs, root, isExclude))].flat();
-}
-const isPossibleGlobRegExp = /[()*?[{}]/;
-const isPossibleUrlRegExp = /^[\d_a-z-]{3,}:\/\//;
-/**
- * If a 'glob' is a path to a directory, then append `**` so that
- * directory searches work.
- * @param glob - a glob, file, or directory
- * @param root - root to use.
- * @returns `**` is appended directories.
- */
-async function adjustPossibleDirectory(glob, root) {
-    const g = typeof glob === 'string'
-        ? {
-            glob,
-            root,
-        }
-        : {
-            glob: glob.glob,
-            root: glob.root ?? root,
-        };
-    // Do not ask the file system to look up obvious glob patterns.
-    if (isPossibleGlobRegExp.test(g.glob)) {
-        return glob;
-    }
-    if (isPossibleUrlRegExp.test(g.glob)) {
-        return glob;
-    }
-    const dirPath = path.resolve(g.root, g.glob);
-    try {
-        const stat = await fs.stat(dirPath);
-        if (stat.isDirectory()) {
-            const useGlob = posix.join(posixPath(g.glob), '**');
-            return typeof glob === 'string' ? useGlob : { ...glob, glob: useGlob };
-        }
-    }
-    catch {
-        // it was not possible to access the dirPath, no problem, just let the file glob search look for it.
-        return glob;
-    }
-    return glob;
-}
-function posixPath(p) {
-    return path.sep === '\\' ? p.replaceAll('\\', '/') : p;
-}
-export async function normalizeFileOrGlobsToRoot(globs, root) {
-    const adjustedGlobs = await Promise.all(globs.map((g) => adjustPossibleDirectory(g, root)));
-    return normalizeGlobsToRoot(adjustedGlobs, root, false);
-}
-function glob(patterns, options) {
-    patterns =
-        typeof patterns === 'string'
-            ? workaroundPicomatchBug(patterns)
-            : patterns.map((g) => workaroundPicomatchBug(g));
-    return tinyGlob(patterns, options);
-}
-//# sourceMappingURL=glob.js.map