@webround/editor 0.0.0-stage → 0.2.0

package/dist/vite-plugins/update.js

@@ -0,0 +1,46 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveInSrc, wrRoute } from './guard.js';
+export function wrUpdatePlugin() {
+    return {
+        name: 'wr-update',
+        configureServer(server) {
+            wrRoute(server, '/wr/update', (req, res) => {
+                if (req.method !== 'PUT') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const { file, patch } = JSON.parse(body);
+                        const filePath = resolveInSrc(file);
+                        if (!filePath) {
+                            res.statusCode = 400;
+                            res.end(JSON.stringify({ error: 'invalid file path' }));
+                            return;
+                        }
+                        const current = fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : {};
+                        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                        for (const [key, value] of Object.entries(patch)) {
+                            if (value === null)
+                                delete current[key];
+                            else
+                                current[key] = value;
+                        }
+                        fs.writeFileSync(filePath, JSON.stringify(current, null, 2));
+                        res.end('ok');
+                    }
+                    catch (err) {
+                        console.error('[wr-update] failed:', err);
+                        res.statusCode = 500;
+                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                    }
+                });
+            });
+        }
+    };
+}
+//# sourceMappingURL=update.js.map

package/dist/vite-plugins/wr-plugins.d.ts

@@ -0,0 +1,15 @@
+import type { Plugin } from 'vite';
+export interface WrPluginsOptions {
+    /**
+     * Host accettati dal dev server (header Host). Serve dietro a proxy/Worker, dove l'host è
+     * pubblico (es. ['.webround.net']). Non impostarlo in locale: lascia attiva la protezione di Vite.
+     */
+    allowedHosts?: true | string[];
+}
+/**
+ * Facade: tutti i plugin dell'editor, nell'ordine giusto. Il vite.config.ts di un progetto
+ * deve solo spargere `...wrPlugins()` accanto a react() e tailwindcss(); aggiungere un plugin
+ * nuovo qui lo rende disponibile a tutti i progetti con un semplice bump di versione.
+ */
+export declare function wrPlugins(options?: WrPluginsOptions): Plugin[];
+//# sourceMappingURL=wr-plugins.d.ts.map

package/dist/vite-plugins/wr-plugins.js

@@ -0,0 +1,34 @@
+import { wrPagesPlugin } from './pages.js';
+import { wrLangsPlugin } from './langs.js';
+import { wrCoreSwapPlugin } from './core-swap.js';
+import { wrOperationsPlugin } from './operations.js';
+import { wrSeoFilesPlugin } from './seo-files.js';
+import { wrHeadPlugin } from './head.js';
+// Imposta solo ciò che gli viene passato: nessun default che allenti la sicurezza in locale.
+function wrServerConfigPlugin(allowedHosts) {
+    return {
+        name: 'wr-server-config',
+        config: () => ({ server: { allowedHosts } }),
+    };
+}
+/**
+ * Facade: tutti i plugin dell'editor, nell'ordine giusto. Il vite.config.ts di un progetto
+ * deve solo spargere `...wrPlugins()` accanto a react() e tailwindcss(); aggiungere un plugin
+ * nuovo qui lo rende disponibile a tutti i progetti con un semplice bump di versione.
+ */
+export function wrPlugins(options = {}) {
+    return [
+        ...(options.allowedHosts ? [wrServerConfigPlugin(options.allowedHosts)] : []),
+        // The one door into the project for the editor's page (see operations/)
+        wrOperationsPlugin(),
+        wrPagesPlugin(),
+        wrLangsPlugin(),
+        // What a crawler must find in the HTML before any script runs (the Search Console tag): in dev and in the build
+        wrHeadPlugin(),
+        // robots.txt and the sitemaps, kept in step with the pages, the languages and the SEO data
+        { ...wrSeoFilesPlugin(), apply: 'serve' },
+        // sostituisce il vecchio `command === 'serve'` del config: lo switch core/editor è solo dev
+        { ...wrCoreSwapPlugin(), apply: 'serve' },
+    ];
+}
+//# sourceMappingURL=wr-plugins.js.map

package/dist/vite-plugins.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from 'vite';
+export declare function wrUpdatePlugin(): Plugin;
+export declare function wrReadPlugin(): Plugin;
+export declare function wrCreatePagePlugin(): Plugin;
+export declare function wrPageScaffold(component: string): string;
+export declare function wrCoreSwapPlugin(): Plugin;
+export declare function wrPagesPlugin(): Plugin;
+export declare function wrPagesApiPlugin(): Plugin;
+export declare function wrLangsPlugin(): Plugin;
+export declare function wrAstPlugin(): Plugin;
+//# sourceMappingURL=vite-plugins.d.ts.map

package/dist/vite-plugins.js

@@ -0,0 +1,518 @@
+import fs from 'fs';
+import path from 'path';
+import { Project, SyntaxKind } from 'ts-morph';
+import { getFields } from '@webround/editor/schema';
+import { createRequire } from 'module';
+const require = createRequire(import.meta.url);
+export function wrUpdatePlugin() {
+    return {
+        name: 'wr-update',
+        configureServer(server) {
+            server.middlewares.use('/wr/update', (req, res) => {
+                if (req.method !== 'PUT') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const { file, patch } = JSON.parse(body);
+                        const filePath = path.resolve(process.cwd(), 'src', file);
+                        const current = fs.existsSync(filePath) ? JSON.parse(fs.readFileSync(filePath, 'utf-8')) : {};
+                        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+                        fs.writeFileSync(filePath, JSON.stringify({ ...current, ...patch }, null, 2));
+                        res.end('ok');
+                    }
+                    catch (err) {
+                        console.error('[wr-update] failed:', err);
+                        res.statusCode = 500;
+                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                    }
+                });
+            });
+        }
+    };
+}
+export function wrReadPlugin() {
+    return {
+        name: 'wr-read',
+        configureServer(server) {
+            server.middlewares.use('/wr/read', (req, res) => {
+                if (req.method !== 'GET') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                try {
+                    const url = new URL(req.url ?? '', 'http://localhost');
+                    const file = url.searchParams.get('file');
+                    if (!file) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'file query param required' }));
+                        return;
+                    }
+                    const srcRoot = path.resolve(process.cwd(), 'src');
+                    const filePath = path.resolve(srcRoot, file);
+                    if (!filePath.startsWith(srcRoot + path.sep)) {
+                        res.statusCode = 400;
+                        res.end(JSON.stringify({ error: 'invalid file path' }));
+                        return;
+                    }
+                    if (!fs.existsSync(filePath)) {
+                        res.setHeader('Content-Type', 'application/json');
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const content = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(content));
+                }
+                catch (err) {
+                    console.error('[wr-read] failed:', err);
+                    res.statusCode = 500;
+                    res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                }
+            });
+        }
+    };
+}
+export function wrCreatePagePlugin() {
+    return {
+        name: 'wr-create-page',
+        configureServer(server) {
+            server.middlewares.use('/wr/create-page', (req, res) => {
+                if (req.method !== 'POST') {
+                    res.statusCode = 405;
+                    res.end();
+                    return;
+                }
+                let body = '';
+                req.on('data', chunk => body += chunk);
+                req.on('end', () => {
+                    try {
+                        const { pageName, component, lazy } = JSON.parse(body);
+                        const pagePath = path.resolve(process.cwd(), 'src', 'config', 'pages', `${pageName}.json`);
+                        const componentPath = path.resolve(process.cwd(), 'src', 'pages', `${component}.tsx`);
+                        const routesPath = path.resolve(process.cwd(), 'src', 'config', 'routes.json');
+                        if (fs.existsSync(pagePath) || fs.existsSync(componentPath)) {
+                            res.statusCode = 409;
+                            res.end(JSON.stringify({ error: 'page or component already exists' }));
+                            return;
+                        }
+                        fs.mkdirSync(path.dirname(pagePath), { recursive: true });
+                        fs.writeFileSync(pagePath, JSON.stringify({}, null, 2));
+                        fs.mkdirSync(path.dirname(componentPath), { recursive: true });
+                        fs.writeFileSync(componentPath, wrPageScaffold(component));
+                        const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                        routes[pageName] = { component, ...(lazy ? { lazy: true } : {}) };
+                        fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                        res.end(JSON.stringify({ ok: true }));
+                    }
+                    catch (err) {
+                        console.error('[wr-create-page] failed:', err);
+                        res.statusCode = 500;
+                        res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                    }
+                });
+            });
+        }
+    };
+}
+export function wrPageScaffold(component) {
+    return `import { WrSection } from '@webround/core';
+
+export default function ${component}() {
+    return <WrSection id="root" />;
+}
+`;
+}
+export function wrCoreSwapPlugin() {
+    let editorPkgDir = null;
+    let editorEntry = null;
+    try {
+        editorEntry = require.resolve('@webround/editor');
+        // risali da editorEntry finche' non trovi la root del pacchetto (dove sta il suo package.json)
+        let dir = path.dirname(editorEntry);
+        while (dir !== path.dirname(dir)) {
+            if (fs.existsSync(path.join(dir, 'package.json'))) {
+                const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf-8'));
+                if (pkg.name === '@webround/editor') {
+                    editorPkgDir = dir;
+                    break;
+                }
+            }
+            dir = path.dirname(dir);
+        }
+    }
+    catch (err) {
+        editorPkgDir = null;
+        editorEntry = null;
+    }
+    return {
+        name: 'wr-core-swap',
+        enforce: 'pre',
+        resolveId(source, importer) {
+            if (!editorEntry || !editorPkgDir)
+                return null;
+            if (source !== '@webround/core')
+                return null;
+            if (importer) {
+                const normalizedImporter = path.resolve(importer);
+                const normalizedEditorDir = path.resolve(editorPkgDir);
+                if (normalizedImporter.startsWith(normalizedEditorDir + path.sep)) {
+                    return null;
+                }
+            }
+            return editorEntry;
+        },
+    };
+}
+const WR_PAGES_VIRTUAL_ID = 'virtual:wr-pages';
+const WR_PAGES_RESOLVED_ID = '\0' + WR_PAGES_VIRTUAL_ID;
+export function wrPagesPlugin() {
+    const routesPath = path.resolve(process.cwd(), 'src', 'config', 'routes.json');
+    function generate() {
+        const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+        const eagerImports = [];
+        const eagerEntries = [];
+        const lazyEntries = [];
+        for (const entry of Object.values(routes)) {
+            if (entry.lazy) {
+                lazyEntries.push(`  ${JSON.stringify(entry.component)}: () => import('/src/pages/${entry.component}.tsx'),`);
+            }
+            else {
+                const varName = `Page_${entry.component}`;
+                eagerImports.push(`import * as ${varName} from '/src/pages/${entry.component}.tsx';`);
+                eagerEntries.push(`  ${JSON.stringify(entry.component)}: ${varName},`);
+            }
+        }
+        return `${eagerImports.join('\n')}
+
+export const eagerModules = {
+${eagerEntries.join('\n')}
+};
+
+export const lazyModules = {
+${lazyEntries.join('\n')}
+};
+`;
+    }
+    return {
+        name: 'wr-pages',
+        resolveId(id) {
+            if (id === WR_PAGES_VIRTUAL_ID)
+                return WR_PAGES_RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== WR_PAGES_RESOLVED_ID)
+                return;
+            this.addWatchFile(routesPath);
+            return generate();
+        },
+        configureServer(server) {
+            server.watcher.add(routesPath);
+            server.watcher.on('change', (file) => {
+                if (path.resolve(file) === routesPath) {
+                    const mod = server.moduleGraph.getModuleById(WR_PAGES_RESOLVED_ID);
+                    if (mod) {
+                        server.moduleGraph.invalidateModule(mod);
+                        server.ws.send({ type: 'full-reload' });
+                    }
+                }
+            });
+        },
+    };
+}
+export function wrPagesApiPlugin() {
+    return {
+        name: 'wr-pages-api',
+        configureServer(server) {
+            server.middlewares.use('/wr/pages', (req, res) => {
+                const routesPath = path.resolve(process.cwd(), 'src', 'config', 'routes.json');
+                if (req.method === 'GET') {
+                    const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify(routes));
+                    return;
+                }
+                if (req.method === 'DELETE' || req.method === 'PATCH') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const payload = body ? JSON.parse(body) : {};
+                            const { pageName } = payload;
+                            if (!pageName) {
+                                res.statusCode = 400;
+                                res.end(JSON.stringify({ error: 'pageName required' }));
+                                return;
+                            }
+                            const routes = JSON.parse(fs.readFileSync(routesPath, 'utf-8'));
+                            const entry = routes[pageName];
+                            if (!entry) {
+                                res.statusCode = 404;
+                                res.end(JSON.stringify({ error: 'page not found' }));
+                                return;
+                            }
+                            const pagePath = path.resolve(process.cwd(), 'src', 'config', 'pages', `${pageName}.json`);
+                            const componentPath = path.resolve(process.cwd(), 'src', 'pages', `${entry.component}.tsx`);
+                            if (req.method === 'DELETE') {
+                                if (fs.existsSync(pagePath))
+                                    fs.unlinkSync(pagePath);
+                                if (fs.existsSync(componentPath))
+                                    fs.unlinkSync(componentPath);
+                                delete routes[pageName];
+                                fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                                res.end(JSON.stringify({ ok: true }));
+                                return;
+                            }
+                            // PATCH: rename route key and/or component
+                            const { newPageName, newComponent, lazy } = payload;
+                            const finalPageName = newPageName ?? pageName;
+                            const finalComponent = newComponent ?? entry.component;
+                            if (finalPageName !== pageName && routes[finalPageName]) {
+                                res.statusCode = 409;
+                                res.end(JSON.stringify({ error: 'target page name already exists' }));
+                                return;
+                            }
+                            const newPagePath = path.resolve(process.cwd(), 'src', 'config', 'pages', `${finalPageName}.json`);
+                            const newComponentPath = path.resolve(process.cwd(), 'src', 'pages', `${finalComponent}.tsx`);
+                            if (fs.existsSync(pagePath) && pagePath !== newPagePath) {
+                                fs.mkdirSync(path.dirname(newPagePath), { recursive: true });
+                                fs.renameSync(pagePath, newPagePath);
+                            }
+                            if (fs.existsSync(componentPath) && componentPath !== newComponentPath) {
+                                fs.mkdirSync(path.dirname(newComponentPath), { recursive: true });
+                                fs.renameSync(componentPath, newComponentPath);
+                            }
+                            delete routes[pageName];
+                            routes[finalPageName] = { component: finalComponent, ...(lazy ? { lazy: true } : {}) };
+                            fs.writeFileSync(routesPath, JSON.stringify(routes, null, 2));
+                            res.end(JSON.stringify({ ok: true, pageName: finalPageName }));
+                        }
+                        catch (err) {
+                            console.error('[wr-pages-api] failed:', err);
+                            res.statusCode = 500;
+                            res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
+                        }
+                    });
+                    return;
+                }
+                res.statusCode = 405;
+                res.end();
+            });
+        }
+    };
+}
+const WR_LANGS_VIRTUAL_ID = 'virtual:wr-langs';
+const WR_LANGS_RESOLVED_ID = '\0' + WR_LANGS_VIRTUAL_ID;
+export function wrLangsPlugin() {
+    const langsPath = path.resolve(process.cwd(), 'src', 'config', 'langs.json');
+    function generate() {
+        if (!fs.existsSync(langsPath)) {
+            return `export const langs = null;\n`;
+        }
+        const langs = JSON.parse(fs.readFileSync(langsPath, 'utf-8'));
+        return `export const langs = ${JSON.stringify(langs)};\n`;
+    }
+    function invalidate(server) {
+        const mod = server.moduleGraph.getModuleById(WR_LANGS_RESOLVED_ID);
+        if (mod) {
+            server.moduleGraph.invalidateModule(mod);
+            server.ws.send({ type: 'full-reload' });
+        }
+    }
+    return {
+        name: 'wr-langs',
+        resolveId(id) {
+            if (id === WR_LANGS_VIRTUAL_ID)
+                return WR_LANGS_RESOLVED_ID;
+        },
+        load(id) {
+            if (id !== WR_LANGS_RESOLVED_ID)
+                return;
+            this.addWatchFile(langsPath);
+            return generate();
+        },
+        configureServer(server) {
+            server.watcher.add(langsPath);
+            const onFsEvent = (file) => {
+                if (path.resolve(file) === langsPath)
+                    invalidate(server);
+            };
+            server.watcher.on('add', onFsEvent);
+            server.watcher.on('change', onFsEvent);
+        },
+    };
+}
+// Lista chiusa: solo questi tag JSX vengono considerati dal parser.
+// Va tenuta sincronizzata con WR_AST_COMPONENTS in @webround/editor/schema.
+const COMPONENT_TO_KIND = {
+    WrVideo: 'video',
+    WrImage: 'image',
+    WrLink: 'link',
+    WrButton: 'button',
+    WrNav: 'nav',
+    WrText: 'text',
+    WrSection: 'section',
+};
+const ROOT = process.cwd();
+function safeResolve(file) {
+    const resolved = path.resolve(ROOT, 'src', file);
+    if (!resolved.startsWith(path.resolve(ROOT, 'src')))
+        return null; // path traversal guard
+    return resolved;
+}
+function findNode(project, filePath, id) {
+    let sourceFile = project.getSourceFile(filePath);
+    if (sourceFile) {
+        sourceFile.refreshFromFileSystemSync();
+    }
+    else {
+        sourceFile = project.addSourceFileAtPathIfExists(filePath);
+    }
+    if (!sourceFile)
+        return null;
+    const candidates = [
+        ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxSelfClosingElement),
+        ...sourceFile.getDescendantsOfKind(SyntaxKind.JsxOpeningElement),
+    ];
+    for (const node of candidates) {
+        const tagName = node.getTagNameNode().getText();
+        const kind = COMPONENT_TO_KIND[tagName];
+        if (!kind)
+            continue;
+        const idAttr = node.getAttribute('id');
+        if (!idAttr || idAttr.getKind() !== SyntaxKind.JsxAttribute)
+            continue;
+        const init = idAttr.getInitializer?.();
+        if (!init || init.getKind() !== SyntaxKind.StringLiteral)
+            continue;
+        if (init.getLiteralValue() !== id)
+            continue;
+        return { node, kind };
+    }
+    return null;
+}
+function readLiteral(node, key) {
+    const attr = node.getAttribute(key);
+    if (!attr || attr.getKind() !== SyntaxKind.JsxAttribute)
+        return { present: false };
+    const init = attr.getInitializer?.();
+    if (!init)
+        return { present: true, value: true }; // <WrVideo autoPlay /> senza valore = booleano true
+    if (init.getKind() === SyntaxKind.StringLiteral)
+        return { present: true, value: init.getLiteralValue() };
+    if (init.getKind() === SyntaxKind.JsxExpression) {
+        const expr = init.getExpression();
+        if (!expr)
+            return { present: false };
+        if (expr.getKind() === SyntaxKind.TrueKeyword)
+            return { present: true, value: true };
+        if (expr.getKind() === SyntaxKind.FalseKeyword)
+            return { present: true, value: false };
+        if (expr.getKind() === SyntaxKind.NumericLiteral)
+            return { present: true, value: Number(expr.getText()) };
+        if (expr.getKind() === SyntaxKind.StringLiteral)
+            return { present: true, value: expr.getLiteralValue() };
+    }
+    return { present: false }; // espressione non letterale: non editabile da qui, per sicurezza
+}
+function writeLiteral(node, key, value) {
+    const existing = node.getAttribute(key);
+    if (value === null) {
+        if (existing && existing.getKind() === SyntaxKind.JsxAttribute)
+            existing.remove();
+        return;
+    }
+    const fieldType = typeof value;
+    let text;
+    if (fieldType === 'string')
+        text = `"${String(value).replace(/"/g, '\\"')}"`;
+    else if (fieldType === 'boolean')
+        text = `{${value}}`;
+    else
+        text = `{${value}}`;
+    if (existing && existing.getKind() === SyntaxKind.JsxAttribute) {
+        existing.setInitializer(text);
+    }
+    else {
+        node.addAttribute({ name: key, initializer: text });
+    }
+}
+export function wrAstPlugin() {
+    const project = new Project({ tsConfigFilePath: path.resolve(ROOT, 'tsconfig.json'), skipAddingFilesFromTsConfig: true });
+    return {
+        name: 'wr-ast-plugin',
+        configureServer(server) {
+            server.middlewares.use('/wr/node', (req, res, next) => {
+                const url = new URL(req.url ?? '', 'http://localhost');
+                const file = url.searchParams.get('file');
+                const id = url.searchParams.get('id');
+                if (req.method === 'GET') {
+                    if (!file || !id) {
+                        res.statusCode = 400;
+                        res.end('missing file/id');
+                        return;
+                    }
+                    const resolved = safeResolve(file);
+                    if (!resolved || !fs.existsSync(resolved)) {
+                        res.statusCode = 404;
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const found = findNode(project, resolved, id);
+                    if (!found) {
+                        res.statusCode = 404;
+                        res.end(JSON.stringify(null));
+                        return;
+                    }
+                    const fields = getFields(found.kind).filter(f => f.backend === 'ast');
+                    const values = {};
+                    for (const f of fields) {
+                        const { present, value } = readLiteral(found.node, f.key);
+                        if (present && value !== undefined)
+                            values[f.key] = value;
+                    }
+                    res.setHeader('Content-Type', 'application/json');
+                    res.end(JSON.stringify({ fields: fields.map(f => f.key), values }));
+                    return;
+                }
+                if (req.method === 'PUT') {
+                    let body = '';
+                    req.on('data', chunk => body += chunk);
+                    req.on('end', () => {
+                        try {
+                            const { file: bodyFile, id: bodyId, key, value } = JSON.parse(body);
+                            const resolved = safeResolve(bodyFile);
+                            if (!resolved) {
+                                res.statusCode = 400;
+                                res.end(JSON.stringify({ error: 'invalid file' }));
+                                return;
+                            }
+                            const found = findNode(project, resolved, bodyId);
+                            if (!found) {
+                                res.statusCode = 404;
+                                res.end(JSON.stringify({ error: 'node not found' }));
+                                return;
+                            }
+                            writeLiteral(found.node, key, value);
+                            found.node.getSourceFile().saveSync();
+                            res.setHeader('Content-Type', 'application/json');
+                            res.end(JSON.stringify({ ok: true }));
+                        }
+                        catch (err) {
+                            res.statusCode = 500;
+                            res.end(JSON.stringify({ error: String(err) }));
+                        }
+                    });
+                    return;
+                }
+                next();
+            });
+        },
+    };
+}
+//# sourceMappingURL=vite-plugins.js.map