@nectar-js/nectar 0.1.0

package/dist/plugins-CGvM19v9.js

@@ -0,0 +1,663 @@
+import { createRequire, registerHooks } from "node:module";
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+//#region src/version.ts
+/** From package.json, which sits one level up from both `src/` and `dist/`. */
+const { version } = createRequire(import.meta.url)("../package.json");
+//#endregion
+//#region src/components/customId.ts
+/** Discord rejects custom IDs longer than this. */
+const MAX_CUSTOM_ID_LENGTH = 100;
+const PREFIX = "n:";
+var CustomIdTooLongError = class extends Error {
+	customId;
+	routeId;
+	constructor(customId, routeId) {
+		super(`Custom ID for ${routeId} is ${customId.length} characters, Discord allows 100. Encode a shorter identifier instead of the full value.`);
+		this.customId = customId;
+		this.routeId = routeId;
+		this.name = "CustomIdTooLongError";
+	}
+};
+/**
+* Builds `n:<shortId>:<v1>:<v2>...`. Values are escaped so they may contain `:` and `\`.
+* Throws when the result is longer than Discord allows; it never truncates.
+*/
+function encodeCustomId(shortId, values, routeId = shortId) {
+	let out = PREFIX + shortId;
+	for (const value of values) out += `:${escapeValue(value)}`;
+	if (out.length > 100) throw new CustomIdTooLongError(out, routeId);
+	return out;
+}
+/**
+* Splits a raw custom ID back into its short ID and positional values.
+* IDs without the Nectar prefix are reported as `not-nectar` so hand-built components pass through.
+*/
+function decodeCustomId(raw) {
+	if (!raw.startsWith(PREFIX)) return {
+		ok: false,
+		reason: "not-nectar"
+	};
+	const shortId = raw.slice(2, 8);
+	if (!/^[0-9a-z]{6}$/.test(shortId)) return {
+		ok: false,
+		reason: "malformed"
+	};
+	const values = [];
+	let index = 8;
+	if (index === raw.length) return {
+		ok: true,
+		shortId,
+		values
+	};
+	if (raw[index] !== ":") return {
+		ok: false,
+		reason: "malformed"
+	};
+	index++;
+	let current = "";
+	while (index < raw.length) {
+		const char = raw[index];
+		if (char === "\\") {
+			const next = raw[index + 1];
+			if (next !== "\\" && next !== ":") return {
+				ok: false,
+				reason: "malformed"
+			};
+			current += next;
+			index += 2;
+			continue;
+		}
+		if (char === ":") {
+			values.push(current);
+			current = "";
+			index++;
+			continue;
+		}
+		current += char;
+		index++;
+	}
+	values.push(current);
+	return {
+		ok: true,
+		shortId,
+		values
+	};
+}
+function escapeValue(value) {
+	return value.replaceAll("\\", "\\\\").replaceAll(":", "\\:");
+}
+//#endregion
+//#region src/compiler/diagnostics.ts
+var Diagnostics = class {
+	items = [];
+	error(code, message, location = {}) {
+		this.push("error", code, message, location);
+	}
+	warn(code, message, location = {}) {
+		this.push("warning", code, message, location);
+	}
+	get hasErrors() {
+		return this.items.some((d) => d.severity === "error");
+	}
+	push(severity, code, message, location) {
+		const item = {
+			code,
+			severity,
+			message
+		};
+		if (location.file !== void 0) item.file = location.file;
+		if (location.route !== void 0) item.route = location.route;
+		this.items.push(item);
+	}
+};
+//#endregion
+//#region src/compiler/load.ts
+/**
+* Imports an application module by absolute path.
+*
+* Relies on Node's native TypeScript type stripping (unflagged since 22.18), so handler
+* files must use erasable syntax only: no enums, namespaces, or parameter properties.
+*
+* With reloading enabled (see `enableModuleReloading`) the URL carries a version query, so a
+* changed file evaluates again on the next import instead of coming back from the ESM cache.
+*/
+async function loadModule(file) {
+	const url = pathToFileURL(file).href;
+	return await (reloading === null ? import(url) : import(versioned(url)));
+}
+let reloading = null;
+/**
+* Turns on cache busting for project files. Used by `nectar dev` only.
+*
+* Every import of a file under `root` gets `?nectar=<content hash>-<generation>` appended, the
+* direct ones here and the transitive ones through a resolve hook. A handler whose content
+* changed therefore gets a new URL and a fresh evaluation; its unchanged imports keep their
+* URL and are shared. Old instances stay in the ESM cache until the process exits.
+*/
+function enableModuleReloading(root) {
+	if (reloading !== null) return;
+	reloading = {
+		root: path.resolve(root),
+		generation: 0
+	};
+	registerHooks({ resolve(specifier, context, next) {
+		const result = next(specifier, context);
+		return {
+			...result,
+			url: versioned(result.url)
+		};
+	} });
+}
+/**
+* Makes every project module evaluate again on its next import. For changes to files the
+* compiler does not track (helpers a handler imports), since nothing knows who imports them.
+*/
+function invalidateModuleGraph() {
+	if (reloading !== null) reloading.generation += 1;
+}
+function versioned(url) {
+	if (reloading === null || !url.startsWith("file:") || url.includes("?") || url.includes("#")) return url;
+	const file = fileURLToPath(url);
+	if (!!path.relative(reloading.root, file).startsWith("..") || file.split(path.sep).includes("node_modules")) return url;
+	let hash;
+	try {
+		hash = createHash("sha1").update(readFileSync(file)).digest("base64url").slice(0, 10);
+	} catch {
+		return url;
+	}
+	return `${url}?nectar=${hash}-${reloading.generation}`;
+}
+//#endregion
+//#region src/compiler/segments.ts
+const STATIC_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const PARAM_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/**
+* Parses one directory name into a route segment.
+*
+* `name`      static
+* `[name]`    dynamic
+* `[...name]` catch-all
+* `(name)`    group, organizational only
+*/
+function parseSegment(dirName) {
+	if (dirName.startsWith("[") || dirName.endsWith("]")) {
+		if (!dirName.startsWith("[") || !dirName.endsWith("]")) return fail(`"${dirName}" has an unmatched bracket. Dynamic segments look like [name].`);
+		const inner = dirName.slice(1, -1);
+		const isCatchAll = inner.startsWith("...");
+		const name = isCatchAll ? inner.slice(3) : inner;
+		if (!PARAM_NAME.test(name)) return fail(`"${dirName}" is not a valid parameter name. Use letters, digits, and underscores, and do not start with a digit.`);
+		return ok({
+			type: isCatchAll ? "catchAll" : "dynamic",
+			name
+		});
+	}
+	if (dirName.startsWith("(") || dirName.endsWith(")")) {
+		if (!dirName.startsWith("(") || !dirName.endsWith(")")) return fail(`"${dirName}" has an unmatched parenthesis. Route groups look like (name).`);
+		const name = dirName.slice(1, -1);
+		if (!STATIC_NAME.test(name)) return fail(`"${dirName}" is not a valid group name. Use letters, digits, hyphens, and underscores.`);
+		return ok({
+			type: "group",
+			name
+		});
+	}
+	if (!STATIC_NAME.test(dirName)) return fail(`"${dirName}" is not a valid segment name. Use letters, digits, hyphens, and underscores, and start with a letter or digit.`);
+	return ok({
+		type: "static",
+		name: dirName
+	});
+}
+/** Renders a segment back into its directory form. Groups render as their directory name. */
+function formatSegment(segment) {
+	switch (segment.type) {
+		case "static": return segment.name;
+		case "dynamic": return `[${segment.name}]`;
+		case "catchAll": return `[...${segment.name}]`;
+		case "group": return `(${segment.name})`;
+	}
+}
+function ok(segment) {
+	return {
+		ok: true,
+		segment
+	};
+}
+function fail(reason) {
+	return {
+		ok: false,
+		reason
+	};
+}
+//#endregion
+//#region src/components/params.ts
+/**
+* Reads the validators `defineComponent` attached to a handler and checks them against the
+* route's parameters. Throws with a developer-facing message when the shape is wrong; the
+* compiler reports it as a diagnostic and the runtime as a load error.
+*/
+function paramValidatorsOf(handler, route) {
+	const declared = handler.params;
+	if (declared === void 0) return {};
+	if (typeof declared !== "object" || declared === null || Array.isArray(declared)) throw new Error(`\`params\` must be an object of validators, got ${typeof declared}.`);
+	const validators = {};
+	for (const [name, validator] of Object.entries(declared)) {
+		if (!route.params.includes(name)) throw new Error(`\`params\` validates "${name}", which is not a parameter of this route. ${route.params.length === 0 ? "It has none." : `It has: ${route.params.join(", ")}.`}`);
+		if (!isValidator(validator)) throw new Error(`\`params.${name}\` must be a function or a Standard Schema, got ${typeof validator}.`);
+		validators[name] = validator;
+	}
+	return validators;
+}
+function isValidator(value) {
+	if (typeof value === "function") return true;
+	if (typeof value !== "object" || value === null) return false;
+	const standard = value["~standard"];
+	return typeof standard === "object" && standard !== null && typeof standard.validate === "function";
+}
+/**
+* Runs every validator against the decoded parameters. Resolves to the first parameter that
+* failed, or `null` when all passed. A validator that throws counts as a failure; the
+* caller decides what to log, so the value never leaves this function.
+*/
+async function findInvalidParam(validators, params) {
+	for (const [name, validator] of Object.entries(validators)) {
+		const value = params[name];
+		if (value === void 0) return name;
+		try {
+			if (typeof validator === "function") {
+				if (await validator(value) === false) return name;
+				continue;
+			}
+			const result = await validator["~standard"].validate(value);
+			if (result.issues !== void 0 && result.issues.length > 0) return name;
+		} catch {
+			return name;
+		}
+	}
+	return null;
+}
+//#endregion
+//#region src/components/compile.ts
+const SELECT_KINDS = /* @__PURE__ */ new Set([
+	"string",
+	"user",
+	"role",
+	"channel",
+	"mentionable"
+]);
+/** Validates the component routes of a route table and resolves their select kinds. */
+async function compileComponents(table) {
+	const diagnostics = new Diagnostics();
+	const candidates = table.routes.filter((r) => r.category === "component");
+	const results = await Promise.all(candidates.map(async (route) => {
+		const own = new Diagnostics();
+		return {
+			route: await compileRoute(route, own),
+			diagnostics: own
+		};
+	}));
+	const routes = [];
+	for (const result of results) {
+		diagnostics.items.push(...result.diagnostics.items);
+		if (result.route !== null) routes.push(result.route);
+	}
+	detectShortIdCollisions(routes, diagnostics);
+	detectDuplicatePatterns(routes, diagnostics);
+	return {
+		routes,
+		diagnostics
+	};
+}
+/**
+* Encodes a custom ID for a compiled route. Throws when a parameter is missing, a value is not
+* a string, or the result exceeds Discord's limit.
+*/
+function customIdFor(route, params = {}) {
+	const values = [];
+	for (const name of route.params) {
+		const value = params[name];
+		if (name === route.catchAll) {
+			if (value === void 0) continue;
+			if (typeof value === "string") {
+				values.push(value);
+				continue;
+			}
+			values.push(...value);
+			continue;
+		}
+		if (typeof value !== "string") throw new TypeError(`Route ${route.id} needs a string for parameter "${name}", got ${describe$1(value)}.`);
+		values.push(value);
+	}
+	for (const name of Object.keys(params)) if (!route.params.includes(name)) throw new TypeError(`Route ${route.id} has no parameter "${name}". ${route.params.length === 0 ? "It takes none." : `It takes: ${route.params.join(", ")}.`}`);
+	return encodeCustomId(route.shortId, values, route.id);
+}
+async function compileRoute(route, diagnostics) {
+	const kind = route.kind;
+	const last = route.segments.at(-1);
+	const catchAll = last?.type === "catchAll" ? last.name : null;
+	const overhead = 8 + route.params.length;
+	if (catchAll !== null) diagnostics.warn("catch-all-route", `${formatSegment(last)} accepts any number of values. Every value counts against Discord's 100 character custom ID limit, and generation throws when it is exceeded.`, {
+		file: route.file,
+		route: route.id
+	});
+	let module;
+	try {
+		module = await loadModule(route.file);
+	} catch (error) {
+		diagnostics.error("module-load-failed", `Could not import this file: ${error instanceof Error ? error.message : String(error)}`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	if (!checkDeclaredRoute(module, route, diagnostics)) return null;
+	try {
+		paramValidatorsOf(module.default, route);
+	} catch (error) {
+		diagnostics.error("invalid-param-validator", `${error instanceof Error ? error.message : String(error)} Pass validators as defineComponent's third argument: { params: { name: (value) => ... } }.`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	let selectKind = null;
+	if (kind === "select") {
+		selectKind = validateSelectKind(module, route, diagnostics);
+		if (selectKind === null) return null;
+	}
+	return {
+		...route,
+		category: "component",
+		kind,
+		selectKind,
+		catchAll,
+		overhead
+	};
+}
+/** A handler made with `defineComponent(path, ...)` must name the route its file sits in. */
+function checkDeclaredRoute(module, route, diagnostics, expected = route.path) {
+	const handler = module.default;
+	if (typeof handler !== "function") return true;
+	const declared = handler.route;
+	if (declared === void 0 || declared === expected) return true;
+	diagnostics.error("route-mismatch", `This file is the route "${expected}" but its handler declares "${String(declared)}". Update the string or move the file.`, {
+		file: route.file,
+		route: route.id
+	});
+	return false;
+}
+function validateSelectKind(module, route, diagnostics) {
+	const kind = module.kind;
+	if (kind === void 0) {
+		diagnostics.error("missing-select-kind", "select.ts must export `kind`: \"string\", \"user\", \"role\", \"channel\", or \"mentionable\".", {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	if (typeof kind !== "string" || !SELECT_KINDS.has(kind)) {
+		diagnostics.error("invalid-select-kind", `\`kind\` is ${describe$1(kind)}. Expected "string", "user", "role", "channel", or "mentionable".`, {
+			file: route.file,
+			route: route.id
+		});
+		return null;
+	}
+	return kind;
+}
+function detectShortIdCollisions(routes, diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const existing = seen.get(route.shortId);
+		if (existing === void 0 || existing.id === route.id) {
+			seen.set(route.shortId, route);
+			continue;
+		}
+		diagnostics.error("short-id-collision", `${route.id} and ${existing.id} hash to the same short ID "${route.shortId}", so their custom IDs would be indistinguishable. Rename one of the directories.`, {
+			file: route.file,
+			route: route.id
+		});
+	}
+}
+/**
+* Two routes of the same kind whose paths differ only in parameter names, like
+* `tickets/[id]/close` and `tickets/[ticketId]/close`, would both claim the same custom IDs.
+*/
+function detectDuplicatePatterns(routes, diagnostics) {
+	const seen = /* @__PURE__ */ new Map();
+	for (const route of routes) {
+		const shape = route.segments.filter((s) => s.type !== "group").map((s) => s.type === "static" ? s.name : s.type === "dynamic" ? "[]" : "[...]").join("/");
+		const key = `${route.kind}#${shape}`;
+		const existing = seen.get(key);
+		if (existing === void 0) {
+			seen.set(key, route);
+			continue;
+		}
+		if (existing.id === route.id) continue;
+		diagnostics.error("duplicate-component-pattern", `${route.id} has the same shape as ${existing.id} (${relative(existing.file)}). Parameter names do not make routes distinct.`, {
+			file: route.file,
+			route: route.id
+		});
+	}
+}
+function describe$1(value) {
+	return typeof value === "string" ? JSON.stringify(value) : typeof value;
+}
+function relative(file) {
+	return path.relative(process.cwd(), file).split(path.sep).join("/");
+}
+//#endregion
+//#region src/components/registry.ts
+/**
+* Component routes the running app knows about, keyed by path. The runtime fills this from
+* the manifest before any handler runs, so `customId()` never needs the manifest itself.
+*/
+const routes = /* @__PURE__ */ new Map();
+function registerComponentRoutes(list) {
+	routes.clear();
+	for (const route of list) routes.set(route.path, route);
+}
+function encodeComponentRoute(path, params) {
+	const route = routes.get(path);
+	if (route === void 0) throw new Error(routes.size === 0 ? `customId("${path}") was called before the runtime registered any routes. Call it from a handler, or from code that runs after start().` : `No component route "${path}". Check the directory name under components/.`);
+	return customIdFor(route, params);
+}
+//#endregion
+//#region src/manifest/emit.ts
+const MANIFEST_FILE = "manifest.json";
+/** Serializes a route graph. `outDir` is where the manifest will live; paths are made relative to it. */
+function toManifest(graph, outDir) {
+	const rel = (file) => posix(path.relative(graph.appDir, file));
+	const base = (route) => {
+		const chains = graph.chains.get(route.file) ?? {
+			middleware: [],
+			errors: []
+		};
+		return {
+			id: route.id,
+			category: route.category,
+			path: route.path,
+			file: rel(route.file),
+			middleware: chains.middleware.map(rel),
+			errors: chains.errors.map(rel),
+			plugins: graph.plugins.get(route.file) ?? []
+		};
+	};
+	const routes = [];
+	for (const command of graph.commands) for (const route of Object.values(command.handlers)) routes.push({
+		...base(route),
+		kind: "command"
+	});
+	for (const entry of graph.autocomplete) routes.push({
+		...base(entry.route),
+		kind: "autocomplete",
+		options: entry.options
+	});
+	for (const route of graph.components) routes.push({
+		...base(route),
+		kind: route.kind,
+		shortId: route.shortId,
+		params: route.params,
+		catchAll: route.catchAll,
+		selectKind: route.selectKind,
+		overhead: route.overhead
+	});
+	for (const event of graph.events) for (const handler of event.handlers) routes.push({
+		...base(handler.route),
+		kind: "event",
+		event: event.name,
+		once: handler.once,
+		order: handler.order
+	});
+	routes.sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id));
+	return {
+		version: 1,
+		nectar: version,
+		appDir: posix(path.relative(path.resolve(outDir), graph.appDir)),
+		routes,
+		commands: graph.commands.map((c) => ({
+			name: c.name,
+			type: c.type,
+			payload: c.payload,
+			handlers: Object.fromEntries(Object.entries(c.handlers).map(([k, r]) => [k, r.id]))
+		})),
+		events: graph.events.map((e) => ({
+			name: e.name,
+			mode: e.mode,
+			handlers: e.handlers.map((h) => h.route.id)
+		}))
+	};
+}
+/** Writes `manifest.json` into `outDir` with sorted keys, so identical graphs give identical bytes. */
+function writeManifest(manifest, outDir) {
+	mkdirSync(outDir, { recursive: true });
+	const file = path.join(outDir, MANIFEST_FILE);
+	writeFileSync(file, `${stableStringify(manifest)}\n`);
+	return file;
+}
+function stableStringify(value) {
+	return JSON.stringify(value, (_key, v) => isPlainObject(v) ? sortKeys(v) : v, 2);
+}
+function sortKeys(object) {
+	const out = {};
+	for (const key of Object.keys(object).sort()) out[key] = object[key];
+	return out;
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function posix(file) {
+	return file.split(path.sep).join("/");
+}
+//#endregion
+//#region src/plugins/transform.ts
+/** A frozen copy of the graph in manifest shape, with absolute file paths. */
+function pluginGraph(graph) {
+	const manifest = toManifest(graph, graph.appDir);
+	const absolute = (file) => path.join(graph.appDir, ...file.split("/"));
+	return deepFreeze(structuredClone({
+		appDir: graph.appDir,
+		routes: manifest.routes.map((route) => ({
+			...route,
+			file: absolute(route.file),
+			middleware: route.middleware.map(absolute),
+			errors: route.errors.map(absolute)
+		})),
+		commands: manifest.commands,
+		events: manifest.events
+	}));
+}
+/**
+* Runs every plugin's `transform` in config order and applies the returned changes to the
+* graph. Problems become diagnostics; a plugin never mutates the graph directly.
+*/
+async function applyPlugins(graph, plugins) {
+	for (const plugin of plugins) {
+		if (plugin.transform === void 0) continue;
+		let changes;
+		try {
+			changes = await plugin.transform(pluginGraph(graph)) ?? [];
+		} catch (error) {
+			graph.diagnostics.error("plugin-failed", `Plugin "${plugin.name}" threw while transforming routes: ${describe(error)}`);
+			continue;
+		}
+		if (!Array.isArray(changes)) {
+			graph.diagnostics.error("plugin-invalid-change", `Plugin "${plugin.name}" returned ${typeof changes} from transform. Return an array of changes, or nothing.`);
+			continue;
+		}
+		for (const change of changes) apply(graph, plugin.name, change);
+	}
+}
+function apply(graph, plugin, change) {
+	const type = isRecord(change) ? change.type : void 0;
+	if (type !== "middleware" && type !== "diagnostic") {
+		graph.diagnostics.error("plugin-invalid-change", `Plugin "${plugin}" returned a change of type ${JSON.stringify(type)}. Known types: middleware, diagnostic.`);
+		return;
+	}
+	if (change.type === "diagnostic") {
+		const { severity, code, message, file, route } = change;
+		const where = {
+			...file === void 0 ? {} : { file },
+			...route === void 0 ? {} : { route }
+		};
+		if (severity === "error") graph.diagnostics.error(code, message, where);
+		else graph.diagnostics.warn(code, message, where);
+		return;
+	}
+	const routes = graph.routes.filter((r) => r.id === change.route && (change.kind === void 0 || r.kind === change.kind));
+	const target = change.kind === void 0 ? change.route : `${change.route} (${change.kind})`;
+	if (routes.length === 0) {
+		graph.diagnostics.error("plugin-unknown-route", `Plugin "${plugin}" adds middleware to route "${target}", which does not exist.`);
+		return;
+	}
+	if (routes.some((r) => r.category === "event")) {
+		graph.diagnostics.error("plugin-invalid-change", `Plugin "${plugin}" adds middleware to route "${target}", but event handlers don't run middleware.`, { route: change.route });
+		return;
+	}
+	if (typeof change.file !== "string" || !path.isAbsolute(change.file) || !existsSync(change.file)) {
+		graph.diagnostics.error("plugin-missing-file", `Plugin "${plugin}" adds middleware from ${JSON.stringify(change.file)}, which is not an absolute path to an existing file.`, { route: change.route });
+		return;
+	}
+	const file = path.normalize(change.file);
+	for (const route of routes) {
+		const chains = graph.chains.get(route.file);
+		if (chains === void 0 || chains.middleware.includes(file)) continue;
+		if (change.position === "inner") chains.middleware.push(file);
+		else chains.middleware.unshift(file);
+		const touched = graph.plugins.get(route.file) ?? [];
+		if (!touched.includes(plugin)) graph.plugins.set(route.file, [...touched, plugin]);
+	}
+}
+function deepFreeze(value) {
+	if (typeof value === "object" && value !== null && !Object.isFrozen(value)) {
+		Object.freeze(value);
+		for (const inner of Object.values(value)) deepFreeze(inner);
+	}
+	return value;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function describe(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/plugins/index.ts
+function definePlugin(plugin) {
+	return plugin;
+}
+/** A plugin misbehaved: threw from a hook, or provided something that clashes. */
+var PluginError = class extends Error {
+	plugin;
+	detail;
+	constructor(plugin, detail) {
+		super(`Plugin "${plugin}": ${detail}`);
+		this.plugin = plugin;
+		this.detail = detail;
+		this.name = "PluginError";
+	}
+};
+//#endregion
+export { MAX_CUSTOM_ID_LENGTH as C, CustomIdTooLongError as S, version as T, parseSegment as _, MANIFEST_FILE as a, loadModule as b, writeManifest as c, checkDeclaredRoute as d, compileComponents as f, formatSegment as g, paramValidatorsOf as h, pluginGraph as i, encodeComponentRoute as l, findInvalidParam as m, definePlugin as n, stableStringify as o, customIdFor as p, applyPlugins as r, toManifest as s, PluginError as t, registerComponentRoutes as u, enableModuleReloading as v, decodeCustomId as w, Diagnostics as x, invalidateModuleGraph as y };
+
+//# sourceMappingURL=plugins-CGvM19v9.js.map