vite-plugin-fvtt 0.2.5 → 0.2.7

package/dist/index.js

@@ -1,692 +0,0 @@
-import path from "path";
-import { glob } from "tinyglobby";
-import fs from "fs/promises";
-import { compilePack } from "@foundryvtt/foundryvtt-cli";
-import { Server } from "socket.io";
-import { io } from "socket.io-client";
-
-//#region src/context.ts
-const context = {};
-
-//#endregion
-//#region src/utils/fs-utils.ts
-var FsUtils = class FsUtils {
-	static async checkType(p, check) {
-		try {
-			const stats = await fs.stat(p);
-			return check(stats);
-		} catch {
-			return false;
-		}
-	}
-	static async fileExists(p) {
-		return FsUtils.checkType(p, (s) => s.isFile());
-	}
-	static async dirExists(p) {
-		return FsUtils.checkType(p, (s) => s.isDirectory());
-	}
-	static async readFile(filePath, encoding = "utf-8") {
-		return fs.readFile(filePath, { encoding });
-	}
-	static async readJson(filePath) {
-		try {
-			const content = await FsUtils.readFile(filePath);
-			return JSON.parse(content);
-		} catch {
-			return null;
-		}
-	}
-};
-var fs_utils_default = FsUtils;
-
-//#endregion
-//#region src/config/env.ts
-function parseEnv(content) {
-	const result = {};
-	for (const line of content.split(/\r?\n/)) {
-		const trimmed = line.trim();
-		if (!trimmed || trimmed.startsWith("#")) continue;
-		const [key, ...rest] = trimmed.split("=");
-		result[key.trim()] = rest.join("=").trim();
-	}
-	return result;
-}
-async function loadEnv() {
-	const envPaths = await glob(".env.foundryvtt*", { absolute: true });
-	let merged = {
-		FOUNDRY_URL: "localhost",
-		FOUNDRY_PORT: "30000"
-	};
-	for (const file of envPaths) {
-		const content = await fs_utils_default.readFile(file, "utf-8");
-		merged = {
-			...merged,
-			...parseEnv(content)
-		};
-	}
-	return {
-		foundryUrl: merged.FOUNDRY_URL,
-		foundryPort: parseInt(merged.FOUNDRY_PORT, 10)
-	};
-}
-
-//#endregion
-//#region src/utils/logger.ts
-var Logger = class Logger {
-	static namespace = "vite-plugin-fvtt";
-	static colors = {
-		info: "\x1B[36m",
-		warn: "\x1B[33m",
-		error: "\x1B[31m"
-	};
-	static reset = "\x1B[0m";
-	initialize(namespace = "vite-plugin-fvtt") {
-		Logger.namespace = namespace;
-	}
-	static format(level, message) {
-		return `${Logger.colors[level] ?? ""}[${Logger.namespace}] [${level.toUpperCase()}]${Logger.reset} ${message}`;
-	}
-	static info(message) {
-		console.log(Logger.format("info", message));
-	}
-	static warn(message) {
-		console.warn(Logger.format("warn", message));
-	}
-	static error(message) {
-		console.error(Logger.format("error", message));
-	}
-	static fail(message) {
-		const formatted = Logger.format("error", Logger.stringify(message));
-		console.error(formatted);
-		throw new Error(formatted);
-	}
-	static stringify(message) {
-		if (message instanceof Error) return message.stack ?? message.message;
-		return typeof message === "string" ? message : JSON.stringify(message, null, 2);
-	}
-};
-var logger_default = Logger;
-
-//#endregion
-//#region src/config/foundryvtt-manifest.ts
-async function loadManifest(config) {
-	if (context?.manifest) return context.manifest;
-	const publicDir = config.publicDir || "public";
-	const paths = [
-		"system.json",
-		"module.json",
-		`${publicDir}/system.json`,
-		`${publicDir}/module.json`
-	].map((f) => path.resolve(process.cwd(), f));
-	const idx = (await Promise.all(paths.map((p) => fs_utils_default.fileExists(p)))).findIndex(Boolean);
-	const foundPath = idx !== -1 ? paths[idx] : void 0;
-	if (!foundPath) logger_default.fail(`Could not find a manifest file (system.json or module.json) in project root or ${publicDir}/.`);
-	try {
-		const data = await fs_utils_default.readJson(foundPath);
-		if (!data.id || typeof data.id !== "string") logger_default.fail(`Manifest at ${foundPath} is missing required "id" field.`);
-		const hasEsmodules = Array.isArray(data.esmodules) && data.esmodules.length > 0;
-		const hasScripts = Array.isArray(data.scripts) && data.scripts.length > 0;
-		if (hasEsmodules === hasScripts) logger_default.fail(`Manifest at ${foundPath} must define exactly one of "esmodules" or "scripts".`);
-		return {
-			manifestType: foundPath.includes("module.json") ? "module" : "system",
-			id: data.id,
-			esmodules: Array.isArray(data.esmodules) ? data.esmodules : [],
-			scripts: Array.isArray(data.scripts) ? data.scripts : [],
-			styles: Array.isArray(data.styles) ? data.styles : [],
-			languages: Array.isArray(data.languages) ? data.languages : [],
-			packs: Array.isArray(data.packs) ? data.packs : []
-		};
-	} catch (err) {
-		logger_default.fail(`Failed to read manifest at ${foundPath}: ${err?.message || err}`);
-	}
-}
-
-//#endregion
-//#region src/config/vite-options.ts
-function createPartialViteConfig(config) {
-	const base = config.base ?? `/${context.manifest?.manifestType}s/${context.manifest?.id}/`;
-	const useEsModules = context.manifest?.esmodules.length === 1;
-	const formats = useEsModules ? ["es"] : ["umd"];
-	const fileName = (useEsModules ? context.manifest?.esmodules[0] : context.manifest?.scripts?.[0]) ?? "scripts/bundle.js";
-	if (!(useEsModules || context.manifest?.scripts?.[0])) logger_default.warn("No output file specified in manifest, using default \"bundle\" in the \"scripts/\" folder");
-	if (!context.manifest?.styles?.length) logger_default.warn("No CSS file found in manifest");
-	const cssFileName = context.manifest?.styles[0] ?? "styles/bundle.css";
-	if (!context.manifest?.styles[0]) logger_default.warn("No output css file specified in manifest, using default \"bundle\" in the \"styles/\" folder");
-	const foundryPort = context.env?.foundryPort ?? 3e4;
-	const foundryUrl = context.env?.foundryUrl ?? "localhost";
-	const entry = (config.build?.lib)?.entry;
-	if (!entry) logger_default.fail("Entry must be specified in lib");
-	if (typeof entry !== "string") logger_default.fail("Only a singular string entry is supported for build.lib.entry");
-	const isWatch = process.argv.includes("--watch") || !!config.build?.watch;
-	return {
-		base,
-		build: {
-			emptyOutDir: config.build?.emptyOutDir ?? !isWatch,
-			lib: {
-				entry,
-				formats,
-				name: context.manifest?.id ?? "bundle",
-				cssFileName: "bundle"
-			},
-			minify: "esbuild",
-			rollupOptions: { output: {
-				entryFileNames: fileName,
-				assetFileNames: (assetInfo) => {
-					if ((assetInfo.names ?? []).some((n) => n.endsWith(".css"))) return cssFileName;
-					return "[name][extname]";
-				}
-			} }
-		},
-		define: { __FVTT_PLUGIN__: {
-			id: context.manifest?.id,
-			isSystem: context.manifest?.manifestType === "system"
-		} },
-		esbuild: config.esbuild ?? {
-			minifyIdentifiers: false,
-			minifySyntax: true,
-			minifyWhitespace: true,
-			keepNames: true
-		},
-		server: {
-			port: foundryPort + 1,
-			proxy: { [`^(?!${base})`]: `http://${foundryUrl}:${foundryPort}` }
-		}
-	};
-}
-
-//#endregion
-//#region src/server/trackers/abstract-file-tracker.ts
-var AbstractFileTracker = class {
-	initialized = false;
-	tracked = /* @__PURE__ */ new Map();
-	watcher = null;
-	config;
-	constructor(config) {
-		this.config = config;
-	}
-	initialize(server) {
-		if (this.initialized) return;
-		this.initialized = true;
-		this.watcher = server.watcher;
-		this.watcher.on("change", (changedPath) => {
-			const value = this.tracked.get(changedPath);
-			if (!value) return;
-			logger_default.info(`Attempting to hot reload ${changedPath}`);
-			const eventData = this.getEventData(changedPath, value);
-			server.ws.send({
-				type: "custom",
-				event: this.updateEvent,
-				data: eventData
-			});
-		});
-	}
-	addFile(value, filePath) {
-		const absPath = path.resolve(filePath);
-		if (!this.tracked.has(absPath)) {
-			this.tracked.set(absPath, value);
-			this.watcher?.add(absPath);
-		}
-	}
-};
-
-//#endregion
-//#region src/server/trackers/language-tracker.ts
-var LanguageTracker = class extends AbstractFileTracker {
-	updateEvent = "foundryvtt-language-update";
-	constructor() {
-		super({});
-	}
-	getEventData() {
-		return {};
-	}
-};
-const languageTracker = new LanguageTracker();
-
-//#endregion
-//#region src/utils/path-utils.ts
-var PathUtils = class PathUtils {
-	static _config = null;
-	static _sourceDirectory = null;
-	static _decodedBase = null;
-	static _publicDir = null;
-	static _outDir = null;
-	static _root = null;
-	static getConfig() {
-		if (!PathUtils._config) {
-			const config = context.config;
-			if (!config) logger_default.fail("Path utils can only be called after vite has resolved the config");
-			PathUtils._config = config;
-		}
-		return PathUtils._config;
-	}
-	static getDecodedBase() {
-		if (!PathUtils._decodedBase) {
-			const config = PathUtils.getConfig();
-			PathUtils._decodedBase = path.posix.normalize(decodeURI(config.base));
-		}
-		return PathUtils._decodedBase;
-	}
-	static getSourceDirectory() {
-		if (!PathUtils._sourceDirectory) {
-			const config = PathUtils.getConfig();
-			const segments = path.normalize(config.build.lib.entry.toString()).split(path.sep).filter(Boolean).filter((s) => s !== ".");
-			const firstFolder = segments.length > 0 ? segments[0] : ".";
-			PathUtils._sourceDirectory = path.join(config.root, firstFolder);
-		}
-		return PathUtils._sourceDirectory;
-	}
-	static getPublicDir() {
-		if (!PathUtils._publicDir) {
-			const config = PathUtils.getConfig();
-			PathUtils._publicDir = path.resolve(config.publicDir);
-		}
-		return PathUtils._publicDir;
-	}
-	static getOutDir() {
-		if (!PathUtils._outDir) {
-			const config = PathUtils.getConfig();
-			PathUtils._outDir = path.resolve(config.build.outDir);
-		}
-		return PathUtils._outDir;
-	}
-	static getRoot() {
-		if (!PathUtils._root) {
-			const config = PathUtils.getConfig();
-			PathUtils._root = path.resolve(config.root);
-		}
-		return PathUtils._root;
-	}
-	static async getOutDirFile(p) {
-		const file = path.join(PathUtils.getOutDir(), p);
-		return await fs_utils_default.fileExists(file) ? file : "";
-	}
-	static async getPublicDirFile(p) {
-		const file = path.join(PathUtils.getPublicDir(), p);
-		return await fs_utils_default.fileExists(file) ? file : "";
-	}
-	static async findLocalFilePath(p) {
-		const fileCandidates = [
-			PathUtils.getPublicDir(),
-			PathUtils.getSourceDirectory(),
-			PathUtils.getRoot()
-		].map((pth) => path.join(pth, p));
-		const idx = (await Promise.all(fileCandidates.map(fs_utils_default.fileExists))).findIndex(Boolean);
-		return idx !== -1 ? fileCandidates[idx] : null;
-	}
-	static isFoundryVTTUrl(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		return path.posix.normalize(p).startsWith(decodedBase);
-	}
-	static async foundryVTTUrlToLocal(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		let pathToTransform = path.posix.normalize("/" + p);
-		if (!pathToTransform.startsWith(decodedBase)) return null;
-		pathToTransform = path.relative(decodedBase, pathToTransform);
-		return PathUtils.findLocalFilePath(pathToTransform);
-	}
-	static localToFoundryVTTUrl(p) {
-		const decodedBase = PathUtils.getDecodedBase();
-		let pathToTransform = path.normalize(p);
-		[
-			PathUtils.getPublicDir(),
-			PathUtils.getSourceDirectory(),
-			PathUtils.getRoot()
-		].forEach((pth) => {
-			if (pathToTransform.startsWith(pth)) pathToTransform = pathToTransform.slice(pth.length);
-		});
-		return path.join(decodedBase, pathToTransform);
-	}
-	static getLanguageSourcePath(p, lang) {
-		const dir = path.parse(p).dir;
-		const finalSegments = path.basename(dir) === lang ? dir : path.join(dir, lang);
-		return path.join(PathUtils.getSourceDirectory(), finalSegments);
-	}
-};
-var path_utils_default = PathUtils;
-
-//#endregion
-//#region src/language/loader.ts
-async function getLocalLanguageFiles(lang, outDir = false) {
-	const language = context.manifest.languages.find((l) => l.lang === lang);
-	if (!language) logger_default.fail(`Cannot find language "${lang}"`);
-	const langPath = language?.path ?? "";
-	if (outDir) return [await path_utils_default.getOutDirFile(langPath)];
-	const publicDirFile = await path_utils_default.getPublicDirFile(langPath);
-	if (publicDirFile !== "") return [publicDirFile];
-	const sourcePath = path_utils_default.getLanguageSourcePath(langPath, lang);
-	if (await fs_utils_default.dirExists(sourcePath)) return await glob(path.join(sourcePath, "**/*.json"), { absolute: true });
-	logger_default.warn(`No language folder found at: ${sourcePath}`);
-	return [];
-}
-async function loadLanguage(lang, outDir = false) {
-	const files = await getLocalLanguageFiles(lang, outDir);
-	const result = /* @__PURE__ */ new Map();
-	const reads = files.map(async (file) => {
-		try {
-			const json = await fs_utils_default.readJson(file);
-			languageTracker.addFile(lang, file);
-			return [file, json];
-		} catch (e) {
-			logger_default.warn(e);
-			return null;
-		}
-	});
-	const results = await Promise.all(reads);
-	for (const entry of results) if (entry) result.set(entry[0], entry[1]);
-	return result;
-}
-
-//#endregion
-//#region src/language/transformer.ts
-function flattenKeys(obj, prefix = "") {
-	const result = {};
-	for (const [key, val] of Object.entries(obj)) {
-		const fullKey = prefix ? `${prefix}.${key}` : key;
-		if (val && typeof val === "object" && !Array.isArray(val)) Object.assign(result, flattenKeys(val, fullKey));
-		else result[fullKey] = val;
-	}
-	return result;
-}
-function expandDotNotationKeys(target, source, depth = 0) {
-	if (depth > 32) logger_default.fail("Max object expansion depth exceeded.");
-	if (!source || typeof source !== "object" || Array.isArray(source)) return source;
-	for (const [key, value] of Object.entries(source)) {
-		let current = target;
-		const parts = key.split(".");
-		const lastKey = parts.pop();
-		for (const part of parts) {
-			if (!(part in current)) current[part] = {};
-			current = current[part];
-		}
-		if (lastKey in current) console.warn(`Warning: Overwriting key "${lastKey}" during transformation.`);
-		current[lastKey] = expandDotNotationKeys({}, value, depth + 1);
-	}
-	return target;
-}
-function transform(dataMap) {
-	const mergedData = {};
-	for (const data of dataMap.values()) expandDotNotationKeys(mergedData, data);
-	return mergedData;
-}
-
-//#endregion
-//#region src/language/validator.ts
-async function validator() {
-	const manifest = context.manifest;
-	const baseLanguageData = await loadLanguage("en", true);
-	if (baseLanguageData.size === 0) {
-		logger_default.error("Base language \"en\" not found or could not be loaded.");
-		return;
-	}
-	const base = flattenKeys(baseLanguageData.values().next().value);
-	for (const lang of manifest.languages) {
-		if (lang.lang === "en") continue;
-		const currentLanguageData = await loadLanguage(lang.lang, true);
-		if (currentLanguageData.size === 0) {
-			logger_default.warn(`Summary for language [${lang.lang}]: Could not be loaded.`);
-			continue;
-		}
-		const current = flattenKeys(currentLanguageData.values().next().value);
-		const missing = Object.keys(base).filter((key) => !(key in current));
-		const extra = Object.keys(current).filter((key) => !(key in base));
-		logger_default.info(`Summary for language [${lang.lang}]:`);
-		if (missing.length) console.warn(`Missing keys: ${missing.length}`, missing.slice(0, 5));
-		if (extra.length) console.warn(`Extra keys: ${extra.length}`, extra.slice(0, 5));
-		if (!missing.length && !extra.length) console.log("	✅ All keys match.");
-	}
-}
-
-//#endregion
-//#region src/packs/compile-packs.ts
-async function compileManifestPacks() {
-	if (!context.manifest?.packs) return;
-	for (const pack of context.manifest.packs) {
-		const srcCandidates = [path.resolve(path_utils_default.getSourceDirectory(), pack.path), path.resolve(path_utils_default.getRoot(), pack.path)];
-		const dest = path.resolve(path_utils_default.getOutDir(), pack.path);
-		let chosenSrc;
-		for (const candidate of srcCandidates) if (await fs_utils_default.dirExists(candidate)) {
-			chosenSrc = candidate;
-			break;
-		}
-		if (!chosenSrc) {
-			logger_default.warn(`Pack path not found for ${pack.path}, skipped.`);
-			continue;
-		}
-		const hasYaml = (await glob(["**/*.yaml", "**/*.yml"], {
-			cwd: chosenSrc,
-			absolute: true
-		})).length > 0;
-		await compilePack(chosenSrc, dest, {
-			yaml: hasYaml,
-			recursive: true
-		});
-		logger_default.info(`Compiled pack ${pack.path} (${hasYaml ? "YAML" : "JSON"}) from ${chosenSrc}`);
-	}
-}
-
-//#endregion
-//#region src/server/trackers/handlebars-tracker.ts
-var HandlebarsTracker = class extends AbstractFileTracker {
-	updateEvent = "foundryvtt-template-update";
-	constructor() {
-		super(context.config);
-	}
-	getEventData(changedPath, value) {
-		return { path: value };
-	}
-};
-const handlebarsTracker = new HandlebarsTracker();
-
-//#endregion
-//#region src/server/http-middleware.ts
-function httpMiddlewareHook(server) {
-	server.middlewares.use(async (req, res, next) => {
-		const config = context.config;
-		if (!path_utils_default.isFoundryVTTUrl(req.url ?? "")) {
-			next();
-			return;
-		}
-		const cssFileName = config.build.lib.cssFileName;
-		const cssEntry = cssFileName ? path_utils_default.localToFoundryVTTUrl(`${cssFileName}.css`) : null;
-		if (path.posix.normalize(req.url ?? "") === cssEntry) {
-			logger_default.info(`Blocking CSS entry to ${req.url}`);
-			res.setHeader("Content-Type", "text/css");
-			res.end("/* The cake is in another castle. */");
-			return;
-		}
-		const languages = context.manifest.languages.filter((lang) => path_utils_default.localToFoundryVTTUrl(lang.path) === path.posix.normalize(req.url ?? ""));
-		if (languages.length === 1) {
-			const lang = languages[0].lang;
-			const language = await loadLanguage(lang);
-			const jsonData = transform(language);
-			res.setHeader("Content-Type", "application/json");
-			res.end(JSON.stringify(jsonData, null, 2));
-			return;
-		}
-		next();
-	});
-}
-
-//#endregion
-//#region src/server/socket-proxy.ts
-function socketProxy(server) {
-	const env = context.env;
-	new Server(server.httpServer, { path: "/socket.io" }).on("connection", (socket) => {
-		const upstream = io(`http://${env.foundryUrl}:${env.foundryPort}`, {
-			transports: ["websocket"],
-			upgrade: false,
-			query: socket.handshake.query
-		});
-		socket.onAny(async (event, ...args) => {
-			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
-			if (event === "template") {
-				const localPath = await path_utils_default.foundryVTTUrlToLocal(args[0]);
-				if (localPath) {
-					const html = await fs_utils_default.readFile(localPath);
-					if (maybeAck) maybeAck({
-						html,
-						success: true
-					});
-					handlebarsTracker.addFile(args[0], localPath);
-					return;
-				}
-			}
-			upstream.emit(event, ...args, (response) => {
-				if (maybeAck) maybeAck(response);
-			});
-		});
-		upstream.onAny((event, ...args) => {
-			const maybeAck = typeof args[args.length - 1] === "function" ? args.pop() : null;
-			socket.emit(event, ...args, (response) => {
-				if (maybeAck) maybeAck(response);
-			});
-		});
-	});
-}
-
-//#endregion
-//#region src/server/index.ts
-function setupDevServer(server) {
-	handlebarsTracker.initialize(server);
-	languageTracker.initialize(server);
-	httpMiddlewareHook(server);
-	socketProxy(server);
-}
-
-//#endregion
-//#region src/server/hmr-client.ts
-var hmr_client_default = `
-if (import.meta.hot) {
-  const FVTT_PLUGIN = __FVTT_PLUGIN__
-
-  function refreshApplications(path = null) {
-    // AppV1 refresh
-    Object.values(foundry.ui.windows).forEach(app => app.render(true))
-    // AppV2 refresh
-    if (path)
-      foundry.applications.instances.forEach(appV2 => {
-        Object.values(appV2.constructor.PARTS ?? {}).forEach(part => {
-          const templates = Array.isArray(part.templates) ? part.templates : []
-          if (part.template === path || templates.includes(path)) appV2.render(true)
-        })
-      })
-    else foundry.applications.instances.forEach(appV2 => appV2.render(true))
-  }
-
-  import.meta.hot.on('foundryvtt-template-update', ({ path }) => {
-    game.socket.emit('template', path, response => {
-      if (response.error) new Error(response.error)
-      let template = undefined
-      try {
-        template = Handlebars.compile(response.html)
-      } catch (error) {
-        console.error(error)
-        return
-      }
-      Handlebars.registerPartial(path, template)
-      console.log(\`Vite | Retrieved and compiled template \${path}\`)
-      refreshApplications(path)
-    })
-  })
-
-  async function hmrLanguage(lang, targetObject = game.i18n.translations) {
-    try {
-      const languages = FVTT_PLUGIN.isSystem
-        ? game.system.languages
-        : game.modules.get(FVTT_PLUGIN.id)?.languages
-      if (!languages) {
-        console.warn(
-          'Vite | Got a HMR request to reload languages, however no languages were found.',
-        )
-        return
-      }
-      const langEntry = languages.find(l => l.lang === lang)
-      if (!langEntry) {
-        console.warn('Vite | Got an HMR request for an undefined language')
-        return
-      }
-
-      const url = langEntry.path
-      const resp = await fetch(url)
-      if (!resp.ok) throw new Error('Failed to fetch language file!')
-
-      const json = await resp.json()
-
-      foundry.utils.mergeObject(targetObject, json)
-      console.log(\`Vite | HMR: Reloaded language '\${lang}'\`)
-    } catch (error) {
-      console.error(\`Vite | HMR: Error reloading language '\${lang}' for \${FVTT_PLUGIN.id}\`, error);
-    }
-  }
-
-  import.meta.hot.on('foundryvtt-language-update', async () => {
-    const currentLang = game.i18n.lang
-    const promises = []
-    if (currentLang !== 'en') {
-      promises.push(hmrLanguage('en', game.i18n._fallback))
-    }
-    promises.push(hmrLanguage(currentLang))
-    await Promise.all(promises)
-    refreshApplications()
-  })
-} else console.error('Vite | HMR is disabled')
-//`;
-
-//#endregion
-//#region src/index.ts
-async function foundryVTTPlugin(options = { buildPacks: true }) {
-	context.env = await loadEnv();
-	return {
-		name: "vite-plugin-fvtt",
-		async config(config) {
-			context.manifest = await loadManifest(config) ?? void 0;
-			return createPartialViteConfig(config);
-		},
-		configResolved(config) {
-			context.config = config;
-		},
-		async generateBundle() {
-			for (const file of ["system.json", "module.json"]) {
-				const src = path.resolve(file);
-				if (!await path_utils_default.getPublicDirFile(file) && await fs_utils_default.fileExists(src)) {
-					this.addWatchFile(src);
-					const manifest = await fs_utils_default.readJson(src);
-					this.emitFile({
-						type: "asset",
-						fileName: file,
-						source: JSON.stringify(manifest, null, 2)
-					});
-				}
-			}
-			const languages = context.manifest?.languages ?? [];
-			if (languages.length > 0) for (const language of languages) {
-				if (await path_utils_default.getPublicDirFile(language.path)) continue;
-				getLocalLanguageFiles(language.lang).then((langFiles) => {
-					langFiles.forEach((file) => this.addWatchFile(file));
-				});
-				const languageDataRaw = await loadLanguage(language.lang);
-				const languageData = transform(languageDataRaw);
-				this.emitFile({
-					type: "asset",
-					fileName: path.join(language.path),
-					source: JSON.stringify(languageData, null, 2)
-				});
-			}
-		},
-		async writeBundle() {
-			if (options.buildPacks) await compileManifestPacks();
-		},
-		closeBundle() {
-			if ((context.manifest?.languages ?? []).length > 0) validator();
-		},
-		load(id) {
-			const config = context.config;
-			const jsFileName = (config.build.rollupOptions?.output).entryFileNames;
-			if (id === jsFileName || id === `/${jsFileName}`) return `import '${`/@fs/${path.resolve(config.build.lib.entry)}`}';\n${hmr_client_default}`;
-		},
-		configureServer: setupDevServer
-	};
-}
-
-//#endregion
-export { foundryVTTPlugin as default };