@rohal12/twee-ts 1.18.2 → 2.1.0

package/dist/watch-targets-BrEYmUwU.cjs

@@ -0,0 +1,643 @@
+/*! @rohal12/twee-ts (Unlicense). Bundles third-party code under its own licence: see THIRD_PARTY_NOTICES. */
+const require_diagnostic_text = require("./diagnostic-text-Bj-UQ0Jl.cjs");
+let node_path = require("node:path");
+let node_fs = require("node:fs");
+//#region src/plugins/diagnostics.ts
+/**
+* How the build plugins turn compile results into bundler errors and warnings.
+*/
+/** Text assembled here is already escaped; its diagnostic separators must survive outer reporters. */
+var ReportedError = class extends Error {};
+/** Returns the warnings; throws a LocatedError when the compile reported errors. */
+function splitDiagnostics(result) {
+	const errors = result.diagnostics.filter((d) => d.level === "error");
+	if (errors.length === 0) return result.diagnostics.filter((d) => d.level === "warning");
+	const error = new ReportedError(errors.map(require_diagnostic_text.formatDiagnostic).join("\n"));
+	const [first] = errors;
+	if (first?.file) {
+		const file = require_diagnostic_text.escapeTerminalControls(first.file);
+		error.id = file;
+		error.loc = {
+			file,
+			line: first.line ?? 1,
+			column: 1
+		};
+	}
+	throw error;
+}
+/** An error thrown by the compiler or bundler, with a TweeTsError's error diagnostics folded into its message. */
+function fatalError(e) {
+	if (e instanceof ReportedError) return e;
+	if (e instanceof require_diagnostic_text.TweeTsError) return new ReportedError([...e.diagnostics.filter((d) => d.level === "error").map(require_diagnostic_text.formatDiagnostic), require_diagnostic_text.escapeTerminalControls(e.message)].join("\n"));
+	const message = require_diagnostic_text.escapeTerminalControls(e instanceof Error ? e.message : String(e));
+	const located = e instanceof Error ? e : void 0;
+	const id = typeof located?.id === "string" ? require_diagnostic_text.escapeTerminalControls(located.id) : void 0;
+	const loc = located?.loc;
+	const file = typeof loc?.file === "string" ? require_diagnostic_text.escapeTerminalControls(loc.file) : void 0;
+	if (message === located?.message && id === located.id && file === loc?.file) return located;
+	const error = new ReportedError(message);
+	if (id !== void 0) error.id = id;
+	if (loc !== void 0 && file !== void 0) error.loc = {
+		...loc,
+		file
+	};
+	return error;
+}
+/** Files covered by directory-only entry watches, including directory links, without following cycles. */
+function* entryFolderFiles(paths) {
+	const visited = /* @__PURE__ */ new Set();
+	function* walk(path, root) {
+		let names;
+		try {
+			const stat = (0, node_fs.statSync)(path);
+			if (!stat.isDirectory()) {
+				if (!root && stat.isFile()) yield path;
+				return;
+			}
+			const key = require_diagnostic_text.identify(path).key;
+			if (visited.has(key)) return;
+			visited.add(key);
+			names = (0, node_fs.readdirSync)(path);
+		} catch (e) {
+			const code = e instanceof Error && "code" in e ? e.code : void 0;
+			if (code === "ENOENT" || code === "ENOTDIR" || code === "ELOOP") return;
+			throw new Error(`Cannot inspect entry watch path ${path}: ${e instanceof Error ? e.message : String(e)}`, { cause: e });
+		}
+		for (const name of names) yield* walk((0, node_path.join)(path, name), false);
+	}
+	for (const path of paths) yield* walk(path, true);
+}
+/**
+* Compiles the story for a plugin, leaving out what a build writes (`outputs`).
+* `writesStory` is whether the story goes to a file (a build, not the dev server): a story path in `outputs`
+* that holds an authored file of a source folder then fails the compile (`OUTPUT_IS_INPUT`), as a named output
+* does. `entryFiles` are physical inputs (files or watched directories) the story must also never replace.
+* Throws a LocatedError when the compile fails or reports errors.
+*/
+async function compileStory(options, outputs, cache, writesStory = false, entryFiles = []) {
+	const inputs = [...entryFiles].map((path) => ({
+		role: "entry",
+		path
+	}));
+	const checkEntry = () => {
+		if (!writesStory) return;
+		const output = require_diagnostic_text.outputPaths({
+			files: outputs.stories ?? [],
+			dirs: []
+		}, "snapshot");
+		require_diagnostic_text.checkNamedInputs(inputs, output, []);
+		for (const path of entryFolderFiles(inputs.map((input) => input.path))) {
+			if (!output.isFile(path) || require_diagnostic_text.isOwnOutput(path) || require_diagnostic_text.isPreviousBuild(path)) continue;
+			require_diagnostic_text.checkNamedInputs([{
+				role: "entry",
+				path
+			}], output, []);
+		}
+	};
+	let result;
+	try {
+		checkEntry();
+		result = await require_diagnostic_text.compileForOutputFile(options, writesStory ? outputs : {
+			files: outputs.files,
+			dirs: outputs.dirs
+		}, cache);
+		checkEntry();
+	} catch (e) {
+		throw fatalError(e);
+	}
+	return {
+		output: result.output,
+		warnings: splitDiagnostics(result).map(require_diagnostic_text.formatDiagnostic)
+	};
+}
+//#endregion
+//#region src/plugins/paths.ts
+/**
+* Path helpers for the bundler plugins. Watchers and bundlers spell one file
+* differently: macOS FSEvents reports /private/var/… for a file under /var/…,
+* Vite resolves module ids through symbolic links, Windows keeps a short 8.3
+* folder name (C:\Users\RUNNER~1) where another tool gives the long one, and
+* a case-insensitive volume takes any letter case. So the plugins compare
+* files by their identity key (see path-identity.ts), and spell a path they
+* hand a watcher by its canonical (real) path.
+*/
+/** The real path of `path`, with forward slashes: how the Vite plugin spells a path it hands a watcher. */
+function canonicalPath(path) {
+	return toPosix(require_diagnostic_text.identify(path).canonical);
+}
+/** The key a file is compared by: two paths name the same file exactly when their keys are equal. */
+function fileKey(path) {
+	return require_diagnostic_text.identify(path).key;
+}
+/** Whether the file with key `key` is one of the folders (or files) with keys `within`, or inside one. */
+function keyWithin(key, within) {
+	return within.some((outer) => require_diagnostic_text.isKeyInside(key, outer, node_path.sep));
+}
+/**
+* The absolute path a bundle writes the file it emits as `fileName` to: inside
+* `output.dir`, or next to `output.file`, either resolved against the working
+* directory, as the bundler resolves them. Undefined when the output names
+* neither, as for a bundle only generated in memory.
+*/
+function emittedFilePath(output, fileName) {
+	const dir = output.dir ?? (output.file === void 0 ? void 0 : (0, node_path.dirname)(output.file));
+	return dir === void 0 ? void 0 : (0, node_path.resolve)(dir, fileName);
+}
+/**
+* The locations a bundler's `output` option names: one output's settings or an
+* array of them, as a config gives them. Outputs that name neither `dir` nor
+* `file`, and anything that isn't an output's settings, are left out.
+*/
+function outputLocations(option) {
+	return (Array.isArray(option) ? option : [option]).flatMap((output) => {
+		if (typeof output !== "object" || output === null) return [];
+		const dir = "dir" in output ? output.dir : void 0;
+		const file = "file" in output ? output.file : void 0;
+		const location = {
+			...typeof dir === "string" ? { dir } : {},
+			...typeof file === "string" ? { file } : {}
+		};
+		return location.dir === void 0 && location.file === void 0 ? [] : [location];
+	});
+}
+/** An empty OutputRecord for a plugin that writes its story as `storyFileName`. */
+function createOutputRecord(storyFileName) {
+	const files = /* @__PURE__ */ new Set();
+	const stories = /* @__PURE__ */ new Set();
+	const dirs = /* @__PURE__ */ new Set();
+	const addFiles = (output, fileNames) => {
+		for (const fileName of fileNames) {
+			const path = emittedFilePath(output, fileName);
+			if (path !== void 0) files.add(path);
+		}
+	};
+	return {
+		addLocation(output) {
+			if (output.dir !== void 0) dirs.add((0, node_path.resolve)(output.dir));
+			if (output.file !== void 0) files.add((0, node_path.resolve)(output.file));
+			addFiles(output, [storyFileName]);
+			const story = emittedFilePath(output, storyFileName);
+			if (story !== void 0) stories.add(story);
+		},
+		addFiles,
+		outputs: () => ({
+			files: [...files],
+			stories: [...stories],
+			dirs: [...dirs]
+		})
+	};
+}
+/**
+* The path with the platform's separators turned into forward slashes. Only Windows has a backslash separator;
+* on POSIX a backslash is an ordinary filename character and stays one.
+*/
+function toPosix(path) {
+	return node_path.sep === "\\" ? path.replaceAll("\\", "/") : path;
+}
+/**
+* Whether `file` is a temporary copy of a Vite config file. Vite writes one next
+* to the config file each time it loads it (when no node_modules folder is
+* above the config, and always under Deno), then deletes it.
+*/
+function isViteConfigTemp(file) {
+	return /\.timestamp-\d+-[0-9a-f]*\.mjs$/.test(file);
+}
+//#endregion
+//#region src/plugins/options.ts
+/**
+* The options both bundler plugins take, checked once where the plugin is
+* created and turned into what the plugin works with: the compile options of a
+* build, the files whose changes rebuild the story, and which of them
+* `compileOptions.exclude` leaves out. The Vite and the Rollup plugin share this,
+* so the same options mean the same thing in both.
+*/
+/** The option names each plugin accepts. */
+const OPTION_NAMES = {
+	rollup: [
+		"sources",
+		"format",
+		"outputFilename",
+		"compileOptions"
+	],
+	vite: [
+		"sources",
+		"format",
+		"outputFilename",
+		"compileOptions",
+		"entry"
+	]
+};
+/** The compile options each plugin sets from an option of its own, by that option's name. */
+const PLUGIN_SET_COMPILE_OPTIONS = [["sources", "sources"], ["formatId", "format"]];
+function fail(kind, message) {
+	throw new require_diagnostic_text.TweeTsError(`twee-ts ${kind} plugin: ${message}`, [], { code: "INVALID_OPTIONS" });
+}
+/** The oldest Vite the plugin works with (the `vite` peer dependency). */
+const MINIMUM_VITE_MAJOR = 8;
+/**
+* Throws a TweeTsError (`INVALID_OPTIONS`) that names twee-ts and the Vite version when Vite is older than the
+* plugin supports, instead of the obscure failure an older Vite gives (a missing `index.html`, say). A version
+* that is not a SemVer version (a custom build) is accepted.
+*/
+function checkViteVersion(viteVersion) {
+	const parsed = require_diagnostic_text.parseVersion(viteVersion);
+	if (parsed === null) return;
+	if (parsed.major < MINIMUM_VITE_MAJOR) fail("vite", `Vite ${viteVersion} is not supported; the plugin needs Vite ${MINIMUM_VITE_MAJOR} or newer. Upgrade Vite, or use an older twee-ts release for this Vite.`);
+}
+/**
+* Characters a file name can't hold on every file system (Windows rejects
+* `<>:"|?*`, the control characters and `\`), and those a URL path reads
+* differently from the file name (`#`, `?`, `%`).
+*/
+const UNPORTABLE = /[\u0000-\u001f\u007f<>:"|?*#%\\]/;
+/** Names Windows reserves for devices, with or without an extension. */
+const WINDOWS_DEVICE = /^(con|prn|aux|nul|com[0-9¹²³]|lpt[0-9¹²³])(\..*)?$/i;
+/**
+* Why `name` can't be an output file name, or undefined when it can. It must be
+* a relative path: names separated by forward slashes, none of them empty, `.`
+* or `..`, nor one a file system or a URL would read differently. The bundler
+* writes it inside the output folder, and the dev server serves it at the same
+* path under the base URL.
+*/
+function outputFilenameProblem(name) {
+	if (name === "") return "it is empty";
+	if (UNPORTABLE.test(name)) return "it holds a character that is not portable in a file name or URL path";
+	if (name.startsWith("/")) return "it is an absolute path";
+	const segments = name.split("/");
+	if (segments.includes("")) return "it has an empty name between slashes, or ends with a slash";
+	if (segments.some((segment) => segment === "." || segment === "..")) return "it has a \".\" or \"..\" segment";
+	if (segments.some((segment) => segment.endsWith(".") || segment.endsWith(" "))) return "a name in it ends with \".\" or a space, which Windows drops";
+	if (segments.some((segment) => WINDOWS_DEVICE.test(segment))) return "a name in it is reserved on Windows";
+}
+function checkString(kind, value, name) {
+	if (value !== void 0 && (typeof value !== "string" || value === "")) fail(kind, `\`${name}\` must be a non-empty string.`);
+}
+function checkStringList(kind, value, name) {
+	if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item === "")) fail(kind, `\`${name}\` must be an array of non-empty strings.`);
+}
+/**
+* Checks the options as a JavaScript caller may pass them, whatever their type
+* says: an object with only the accepted option names, each of the right type.
+*/
+function checkOptions(kind, options) {
+	if (!require_diagnostic_text.isRecord(options)) fail(kind, "the options must be an object.");
+	const accepted = OPTION_NAMES[kind];
+	const unknown = Object.keys(options).filter((key) => !accepted.includes(key));
+	if (unknown.length > 0) fail(kind, `unknown option ${unknown.map((key) => `\`${key}\``).join(", ")}; the options are ${accepted.join(", ")}.`);
+	checkStringList(kind, options["sources"], "sources");
+	for (const name of [
+		"format",
+		"outputFilename",
+		"entry"
+	]) checkString(kind, options[name], name);
+	const outputFilename = options["outputFilename"];
+	const problem = typeof outputFilename === "string" ? outputFilenameProblem(outputFilename) : void 0;
+	if (problem !== void 0) fail(kind, `\`outputFilename\` ${JSON.stringify(outputFilename)} can't be used: ${problem}.`);
+	const compileOptions = options["compileOptions"];
+	if (compileOptions === void 0) return;
+	if (!require_diagnostic_text.isRecord(compileOptions)) fail(kind, "`compileOptions` must be an object.");
+	for (const [key, own] of PLUGIN_SET_COMPILE_OPTIONS) if (Object.hasOwn(compileOptions, key)) fail(kind, `\`compileOptions.${key}\` is not accepted; set the plugin's \`${own}\` option instead.`);
+	const errors = require_diagnostic_text.compileOptionErrors(compileOptions, [], "compileOptions.");
+	if (errors.length > 0) fail(kind, errors.join(" "));
+}
+/** Absolute forward-slash path of a path given relative to the working directory. */
+function absolute(path) {
+	return toPosix(require_diagnostic_text.absolutePathSpelling(path));
+}
+/**
+* How the compiler spells `file` when it finds it by walking each source it is inside: the source
+* as given, then the file's path below it. A watcher may report the real path of a file the sources
+* (and so the exclude globs) reach through a link, which the globs would otherwise not match.
+*/
+function spellingsUnderSources(file, sources) {
+	const real = require_diagnostic_text.identify(file).canonical;
+	return sources.flatMap((source) => {
+		const below = (0, node_path.relative)(require_diagnostic_text.identify(source).canonical, real);
+		return below === ".." || below.startsWith(`..${node_path.sep}`) || (0, node_path.isAbsolute)(below) ? [] : [`${absolute(source)}/${toPosix(below)}`];
+	});
+}
+/**
+* Checks a plugin's options and resolves them. Throws a TweeTsError naming the
+* option for anything outside what the plugin supports: an unknown option, a
+* value of the wrong type, `compileOptions.sources` or `compileOptions.formatId`
+* (the plugin's `sources` and `format` set them), or an output file name that
+* is not a plain relative path.
+*/
+function resolvePluginOptions(kind, options) {
+	checkOptions(kind, options);
+	const { sources, format, entry } = options;
+	const compileOptions = { ...options.compileOptions };
+	const { headFile, modules = [], exclude = [] } = compileOptions;
+	const notExcludable = [...headFile === void 0 ? [] : [headFile], ...modules].map(absolute);
+	return {
+		sources: [...sources],
+		format,
+		outputFilename: options.outputFilename ?? "index.html",
+		compileOptions,
+		entry: entry === void 0 ? void 0 : require_diagnostic_text.absolutePathSpelling(entry),
+		inputs: [...sources.map(absolute), ...notExcludable],
+		excluded: (file) => exclude.length > 0 && [file, ...spellingsUnderSources(file, sources)].some((spelling) => require_diagnostic_text.isExcluded(spelling, exclude)) && !notExcludable.some((path) => require_diagnostic_text.isSameOrInside(file, path)),
+		compile: (inline = []) => ({
+			...compileOptions,
+			sources: [...sources, ...inline],
+			formatId: format
+		})
+	};
+}
+//#endregion
+//#region src/plugins/watch-targets.ts
+/**
+* What a bundler's watch mode (`rollup --watch`, `vite build --watch`) is told
+* to watch for the story, whose inputs the plugins read outside the module
+* graph. Rollup's watcher and the Rolldown watcher of later Vite 8 releases
+* watch a registered folder recursively; earlier ones see only the folder's own
+* entries. So every path is registered on its own as well.
+*/
+const NOTHING = {
+	targets: [],
+	whole: false
+};
+/**
+* The paths to register for the inputs (forward-slash paths): every file under
+* them that source discovery reads, but those `skip` returns true for, and no
+* path the build writes (`outputs`). With `real` spelling, each link an input is reached through is registered as
+* authored too, every hop of a chain of links (see linksOnTheWay), but those that lead to a folder holding an output.
+*
+* A folder is registered, with what it holds, only when watching it reports
+* nothing the story leaves out: nothing below it is skipped (an `exclude`
+* match), is an output or holds one, or is a link to a folder (which source
+* discovery doesn't follow, and which may lead to the output). Of any other
+* folder only what it holds is registered, minus those, so writing the outputs
+* or editing an excluded file starts no build. A file added straight to such a folder is read at the next build
+* something else starts. An input that can't be read is registered as it is
+* (unless it is an output folder), so its creation may start a build; below an
+* input, what can't be read is left out, as source discovery leaves it out.
+*/
+function watchTargets(inputs, skip, outputs, spelling) {
+	return watchPlan(inputs, skip, outputs, spelling).targets;
+}
+/** What watchTargets registers for the inputs, and the links they are reached through. */
+function watchPlan(inputs, skip, outputs, spelling) {
+	const links = /* @__PURE__ */ new Set();
+	/** Every link on the way to `path`, noted; those registered by real path are the ones that lead to no output. */
+	const hopsOf = (path) => {
+		const hops = linksOnTheWay(path);
+		for (const hop of hops) links.add(hop);
+		return hops.filter((hop) => !outputs.holds(require_diagnostic_text.realPathOf(hop))).map(toPosix);
+	};
+	const reals = /* @__PURE__ */ new Map();
+	const spell = (path, real, isRoot) => {
+		if (spelling === "real") return [toPosix(real), ...isRoot || isLink(path) ? hopsOf(path) : []];
+		if (!isRoot && isLink(path)) for (const hop of linksOnTheWay(path)) links.add(hop);
+		if (isLoop(path)) return [];
+		if (!isLoop(real)) reals.set(path, real);
+		return [path];
+	};
+	const walk = (path, real, isRoot) => {
+		if (outputs.isFile(real) || !isRoot && outputs.isDir(real)) return NOTHING;
+		let entry;
+		let names;
+		try {
+			entry = isRoot ? {
+				stat: (0, node_fs.statSync)(path),
+				real
+			} : require_diagnostic_text.walkedEntry(path, real);
+			if (entry === void 0 || outputs.isFile(entry.real)) return NOTHING;
+			if (!entry.stat.isDirectory()) return skip(path) ? NOTHING : {
+				targets: spell(path, entry.real, isRoot),
+				whole: true
+			};
+			names = (0, node_fs.readdirSync)(path);
+		} catch {
+			return isRoot && !outputs.isDir(real) ? {
+				targets: spell(path, real, isRoot),
+				whole: true
+			} : NOTHING;
+		}
+		const folder = entry.real;
+		const children = names.map((name) => walk(`${path}/${name}`, (0, node_path.join)(folder, name), false));
+		const held = children.flatMap((child) => child.targets);
+		const whole = !outputs.holds(folder) && children.every((child) => child.whole);
+		return whole ? {
+			targets: [...spell(path, folder, isRoot), ...held],
+			whole
+		} : {
+			targets: held,
+			whole
+		};
+	};
+	const targets = inputs.flatMap((input) => {
+		for (const link of linksOnTheWay(input)) links.add(link);
+		return [...spelling === "real" ? ancestorLinks(input, outputs) : [], ...walk(input, require_diagnostic_text.realPathOf(input), true).targets];
+	});
+	return {
+		targets: [...new Set(targets)],
+		links: [...links],
+		reals
+	};
+}
+/**
+* The paths to register, besides the real paths of the files a bundle read, so that the build watch sees what
+* changes how the entry's imports resolve: for each spelling (absolute) of an import that reaches a file through
+* links, every link on the way (see linksOnTheWay), the links a link leads through too (replacing any of them changes
+* the file the import reads); and for a spelling
+* that reaches nothing, the nearest folder that exists, where creating the file shows (a bundle that failed for a
+* missing import). A folder that holds a build output is left out, since the watcher would report what the build
+* writes there and rebuild for ever: a file created straight in it is read with the next build something else starts.
+*/
+function importWatchTargets(authored, outputs) {
+	const targets = /* @__PURE__ */ new Set();
+	const missing = [];
+	for (const spelling of authored) {
+		if ((0, node_fs.existsSync)(spelling)) {
+			if (toPosix(require_diagnostic_text.realPathOf(spelling)) === toPosix(spelling)) continue;
+			for (const link of linksOnTheWay(spelling)) if (!outputs.holds(require_diagnostic_text.realPathOf(link))) targets.add(toPosix(link));
+			continue;
+		}
+		missing.push(spelling);
+	}
+	for (const folder of missingImportFolders(missing)) if (!outputs.holds(require_diagnostic_text.realPathOf(folder))) targets.add(toPosix(folder));
+	return [...targets];
+}
+/**
+* The nearest folder that exists, for each of the paths in `authored` that reaches nothing: where creating that
+* file (or the folders above it) shows. Of a path that exists there is none, and neither is the root of a file
+* system (an absolute import such as `/missing.js`, which Vite reads from the project root first), which no watcher
+* is asked to watch whole.
+*/
+function missingImportFolders(authored) {
+	const folders = /* @__PURE__ */ new Set();
+	for (const spelling of authored) {
+		if ((0, node_fs.existsSync)(spelling)) continue;
+		let folder = (0, node_path.dirname)(spelling);
+		while (!(0, node_fs.existsSync)(folder) && (0, node_path.dirname)(folder) !== folder) folder = (0, node_path.dirname)(folder);
+		if ((0, node_fs.existsSync)(folder) && (0, node_path.dirname)(folder) !== folder) folders.add(folder);
+	}
+	return [...folders];
+}
+/**
+* The links among the folders above `path`, as authored (forward slashes), every hop of a chain, in the order they are
+* followed. Replacing one of them changes what the input is, and only its own location sees that. A link directly in
+* the root of the file system (`/var` on macOS) is the system's own alias and is left out, as is a link to a folder that
+* holds a build output, since watching it whole would rebuild for what the build writes.
+*/
+function ancestorLinks(path, outputs) {
+	return linksOnTheWay((0, node_path.dirname)(path)).filter((link) => !outputs.holds(require_diagnostic_text.realPathOf(link))).map(toPosix);
+}
+/** How many links the file system follows for one path before it gives up (ELOOP on Linux). */
+const MAX_LINK_HOPS = 40;
+/**
+* Every link the file system follows to reach `path`, in the order it follows them: each link along the path, and
+* along the target each one leads to, so every hop of a link to a link (a chain) is there. A link directly in the
+* root of the file system (`/var` on macOS) is the system's own alias and is left out. The walk ends where a name
+* reaches nothing, or after as many hops as the file system follows.
+*/
+function linksOnTheWay(path) {
+	const links = [];
+	/** The names of a path or a link's target below its root; `..` is kept for the walk to take. */
+	const names = (text, root) => text.slice(root.length).split(node_path.sep === "\\" ? /[/\\]/ : "/").filter((name) => name !== "" && name !== ".");
+	const start = require_diagnostic_text.absolutePathSpelling(path);
+	let reached = (0, node_path.parse)(start).root;
+	let rest = names(start, reached);
+	for (let hops = 0; rest.length > 0 && hops <= MAX_LINK_HOPS;) {
+		const [name = "", ...more] = rest;
+		rest = more;
+		if (name === "..") {
+			reached = (0, node_path.dirname)(reached);
+			continue;
+		}
+		const next = (0, node_path.join)(reached, name);
+		let target;
+		try {
+			target = (0, node_fs.lstatSync)(next).isSymbolicLink() ? (0, node_fs.readlinkSync)(next) : void 0;
+		} catch {
+			break;
+		}
+		if (target === void 0) {
+			reached = next;
+			continue;
+		}
+		hops += 1;
+		if ((0, node_path.dirname)(next) !== (0, node_path.dirname)((0, node_path.dirname)(next))) links.push(next);
+		const root = (0, node_path.isAbsolute)(target) ? (0, node_path.parse)(target).root : "";
+		if (root !== "") reached = root;
+		rest = [...names(target, root), ...rest];
+	}
+	return links;
+}
+/** Whether `path` is a loop of links, which the file system gives up following (ELOOP). */
+function isLoop(path) {
+	try {
+		(0, node_fs.statSync)(path);
+		return false;
+	} catch (error) {
+		return error instanceof Error && Reflect.get(error, "code") === "ELOOP";
+	}
+}
+/** Whether `path` is a symbolic link (or a Windows junction); a path that can't be read is none. */
+function isLink(path) {
+	try {
+		return (0, node_fs.lstatSync)(path).isSymbolicLink();
+	} catch {
+		return false;
+	}
+}
+//#endregion
+Object.defineProperty(exports, "canonicalPath", {
+	enumerable: true,
+	get: function() {
+		return canonicalPath;
+	}
+});
+Object.defineProperty(exports, "checkViteVersion", {
+	enumerable: true,
+	get: function() {
+		return checkViteVersion;
+	}
+});
+Object.defineProperty(exports, "compileStory", {
+	enumerable: true,
+	get: function() {
+		return compileStory;
+	}
+});
+Object.defineProperty(exports, "createOutputRecord", {
+	enumerable: true,
+	get: function() {
+		return createOutputRecord;
+	}
+});
+Object.defineProperty(exports, "emittedFilePath", {
+	enumerable: true,
+	get: function() {
+		return emittedFilePath;
+	}
+});
+Object.defineProperty(exports, "fatalError", {
+	enumerable: true,
+	get: function() {
+		return fatalError;
+	}
+});
+Object.defineProperty(exports, "fileKey", {
+	enumerable: true,
+	get: function() {
+		return fileKey;
+	}
+});
+Object.defineProperty(exports, "importWatchTargets", {
+	enumerable: true,
+	get: function() {
+		return importWatchTargets;
+	}
+});
+Object.defineProperty(exports, "isViteConfigTemp", {
+	enumerable: true,
+	get: function() {
+		return isViteConfigTemp;
+	}
+});
+Object.defineProperty(exports, "keyWithin", {
+	enumerable: true,
+	get: function() {
+		return keyWithin;
+	}
+});
+Object.defineProperty(exports, "missingImportFolders", {
+	enumerable: true,
+	get: function() {
+		return missingImportFolders;
+	}
+});
+Object.defineProperty(exports, "outputLocations", {
+	enumerable: true,
+	get: function() {
+		return outputLocations;
+	}
+});
+Object.defineProperty(exports, "resolvePluginOptions", {
+	enumerable: true,
+	get: function() {
+		return resolvePluginOptions;
+	}
+});
+Object.defineProperty(exports, "toPosix", {
+	enumerable: true,
+	get: function() {
+		return toPosix;
+	}
+});
+Object.defineProperty(exports, "watchPlan", {
+	enumerable: true,
+	get: function() {
+		return watchPlan;
+	}
+});
+Object.defineProperty(exports, "watchTargets", {
+	enumerable: true,
+	get: function() {
+		return watchTargets;
+	}
+});
+
+//# sourceMappingURL=watch-targets-BrEYmUwU.cjs.map