nitro-nightly 4.0.0-20251010-091516-7cafddba → 4.0.0-20251030-091344-d4418b98

package/dist/_chunks/_deps/webpack-virtual-modules.mjs

@@ -0,0 +1,360 @@
+import require$$0 from 'constants';
+import { a as getDefaultExportFromCjs } from './commondir.mjs';
+import sysPath__default from 'path';
+
+var virtualStats = {};
+
+var hasRequiredVirtualStats;
+
+function requireVirtualStats () {
+	if (hasRequiredVirtualStats) return virtualStats;
+	hasRequiredVirtualStats = 1;
+	var __importDefault = (virtualStats && virtualStats.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	Object.defineProperty(virtualStats, "__esModule", { value: true });
+	virtualStats.VirtualStats = void 0;
+	const constants_1 = __importDefault(require$$0);
+	class VirtualStats {
+	    constructor(config) {
+	        for (const key in config) {
+	            if (!Object.prototype.hasOwnProperty.call(config, key)) {
+	                continue;
+	            }
+	            this[key] = config[key];
+	        }
+	    }
+	    _checkModeProperty(property) {
+	        return (this.mode & constants_1.default.S_IFMT) === property;
+	    }
+	    isDirectory() {
+	        return this._checkModeProperty(constants_1.default.S_IFDIR);
+	    }
+	    isFile() {
+	        return this._checkModeProperty(constants_1.default.S_IFREG);
+	    }
+	    isBlockDevice() {
+	        return this._checkModeProperty(constants_1.default.S_IFBLK);
+	    }
+	    isCharacterDevice() {
+	        return this._checkModeProperty(constants_1.default.S_IFCHR);
+	    }
+	    isSymbolicLink() {
+	        return this._checkModeProperty(constants_1.default.S_IFLNK);
+	    }
+	    isFIFO() {
+	        return this._checkModeProperty(constants_1.default.S_IFIFO);
+	    }
+	    isSocket() {
+	        return this._checkModeProperty(constants_1.default.S_IFSOCK);
+	    }
+	}
+	virtualStats.VirtualStats = VirtualStats;
+	
+	return virtualStats;
+}
+
+var lib;
+var hasRequiredLib;
+
+function requireLib () {
+	if (hasRequiredLib) return lib;
+	hasRequiredLib = 1;
+	var __importDefault = (lib && lib.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
+	const path_1 = __importDefault(sysPath__default);
+	const virtual_stats_1 = requireVirtualStats();
+	let inode = 45000000;
+	const ALL = 'all';
+	const STATIC = 'static';
+	const DYNAMIC = 'dynamic';
+	function checkActivation(instance) {
+	    if (!instance._compiler) {
+	        throw new Error('You must use this plugin only after creating webpack instance!');
+	    }
+	}
+	function getModulePath(filePath, compiler) {
+	    return path_1.default.isAbsolute(filePath) ? filePath : path_1.default.join(compiler.context, filePath);
+	}
+	function createWebpackData(result) {
+	    return (backendOrStorage) => {
+	        if (backendOrStorage._data) {
+	            const curLevelIdx = backendOrStorage._currentLevel;
+	            const curLevel = backendOrStorage._levels[curLevelIdx];
+	            return {
+	                result,
+	                level: curLevel,
+	            };
+	        }
+	        return [null, result];
+	    };
+	}
+	function getData(storage, key) {
+	    if (storage._data instanceof Map) {
+	        return storage._data.get(key);
+	    }
+	    else if (storage._data) {
+	        return storage.data[key];
+	    }
+	    else if (storage.data instanceof Map) {
+	        return storage.data.get(key);
+	    }
+	    else {
+	        return storage.data[key];
+	    }
+	}
+	function setData(backendOrStorage, key, valueFactory) {
+	    const value = valueFactory(backendOrStorage);
+	    if (backendOrStorage._data instanceof Map) {
+	        backendOrStorage._data.set(key, value);
+	    }
+	    else if (backendOrStorage._data) {
+	        backendOrStorage.data[key] = value;
+	    }
+	    else if (backendOrStorage.data instanceof Map) {
+	        backendOrStorage.data.set(key, value);
+	    }
+	    else {
+	        backendOrStorage.data[key] = value;
+	    }
+	}
+	function getStatStorage(fileSystem) {
+	    if (fileSystem._statStorage) {
+	        return fileSystem._statStorage;
+	    }
+	    else if (fileSystem._statBackend) {
+	        return fileSystem._statBackend;
+	    }
+	    else {
+	        throw new Error("Couldn't find a stat storage");
+	    }
+	}
+	function getFileStorage(fileSystem) {
+	    if (fileSystem._readFileStorage) {
+	        return fileSystem._readFileStorage;
+	    }
+	    else if (fileSystem._readFileBackend) {
+	        return fileSystem._readFileBackend;
+	    }
+	    else {
+	        throw new Error("Couldn't find a readFileStorage");
+	    }
+	}
+	function getReadDirBackend(fileSystem) {
+	    if (fileSystem._readdirBackend) {
+	        return fileSystem._readdirBackend;
+	    }
+	    else if (fileSystem._readdirStorage) {
+	        return fileSystem._readdirStorage;
+	    }
+	    else {
+	        throw new Error("Couldn't find a readDirStorage from Webpack Internals");
+	    }
+	}
+	function getRealpathBackend(fileSystem) {
+	    if (fileSystem._realpathBackend) {
+	        return fileSystem._realpathBackend;
+	    }
+	}
+	class VirtualModulesPlugin {
+	    constructor(modules) {
+	        this._compiler = null;
+	        this._watcher = null;
+	        this._staticModules = modules || null;
+	    }
+	    getModuleList(filter = ALL) {
+	        var _a, _b;
+	        let modules = {};
+	        const shouldGetStaticModules = filter === ALL || filter === STATIC;
+	        const shouldGetDynamicModules = filter === ALL || filter === DYNAMIC;
+	        if (shouldGetStaticModules) {
+	            modules = Object.assign(Object.assign({}, modules), this._staticModules);
+	        }
+	        if (shouldGetDynamicModules) {
+	            const finalInputFileSystem = (_a = this._compiler) === null || _a === void 0 ? void 0 : _a.inputFileSystem;
+	            const virtualFiles = (_b = finalInputFileSystem === null || finalInputFileSystem === void 0 ? void 0 : finalInputFileSystem._virtualFiles) !== null && _b !== void 0 ? _b : {};
+	            const dynamicModules = {};
+	            Object.keys(virtualFiles).forEach((key) => {
+	                dynamicModules[key] = virtualFiles[key].contents;
+	            });
+	            modules = Object.assign(Object.assign({}, modules), dynamicModules);
+	        }
+	        return modules;
+	    }
+	    writeModule(filePath, contents) {
+	        if (!this._compiler) {
+	            throw new Error(`Plugin has not been initialized`);
+	        }
+	        checkActivation(this);
+	        const len = contents ? contents.length : 0;
+	        const time = Date.now();
+	        const date = new Date(time);
+	        const stats = new virtual_stats_1.VirtualStats({
+	            dev: 8675309,
+	            nlink: 0,
+	            uid: 1000,
+	            gid: 1000,
+	            rdev: 0,
+	            blksize: 4096,
+	            ino: inode++,
+	            mode: 33188,
+	            size: len,
+	            blocks: Math.floor(len / 4096),
+	            atime: date,
+	            mtime: date,
+	            ctime: date,
+	            birthtime: date,
+	        });
+	        const modulePath = getModulePath(filePath, this._compiler);
+	        if (process.env.WVM_DEBUG)
+	            console.log(this._compiler.name, 'Write virtual module:', modulePath, contents);
+	        let finalWatchFileSystem = this._watcher && this._watcher.watchFileSystem;
+	        while (finalWatchFileSystem && finalWatchFileSystem.wfs) {
+	            finalWatchFileSystem = finalWatchFileSystem.wfs;
+	        }
+	        let finalInputFileSystem = this._compiler.inputFileSystem;
+	        while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) {
+	            finalInputFileSystem = finalInputFileSystem._inputFileSystem;
+	        }
+	        finalInputFileSystem._writeVirtualFile(modulePath, stats, contents);
+	        if (finalWatchFileSystem &&
+	            finalWatchFileSystem.watcher &&
+	            (finalWatchFileSystem.watcher.fileWatchers.size || finalWatchFileSystem.watcher.fileWatchers.length)) {
+	            const fileWatchers = finalWatchFileSystem.watcher.fileWatchers instanceof Map
+	                ? Array.from(finalWatchFileSystem.watcher.fileWatchers.values())
+	                : finalWatchFileSystem.watcher.fileWatchers;
+	            for (let fileWatcher of fileWatchers) {
+	                if ('watcher' in fileWatcher) {
+	                    fileWatcher = fileWatcher.watcher;
+	                }
+	                if (fileWatcher.path === modulePath) {
+	                    if (process.env.DEBUG)
+	                        console.log(this._compiler.name, 'Emit file change:', modulePath, time);
+	                    delete fileWatcher.directoryWatcher._cachedTimeInfoEntries;
+	                    fileWatcher.emit('change', time, null);
+	                }
+	            }
+	        }
+	    }
+	    apply(compiler) {
+	        this._compiler = compiler;
+	        const afterEnvironmentHook = () => {
+	            let finalInputFileSystem = compiler.inputFileSystem;
+	            while (finalInputFileSystem && finalInputFileSystem._inputFileSystem) {
+	                finalInputFileSystem = finalInputFileSystem._inputFileSystem;
+	            }
+	            if (!finalInputFileSystem._writeVirtualFile) {
+	                const originalPurge = finalInputFileSystem.purge;
+	                finalInputFileSystem.purge = () => {
+	                    originalPurge.apply(finalInputFileSystem, []);
+	                    if (finalInputFileSystem._virtualFiles) {
+	                        Object.keys(finalInputFileSystem._virtualFiles).forEach((file) => {
+	                            const data = finalInputFileSystem._virtualFiles[file];
+	                            finalInputFileSystem._writeVirtualFile(file, data.stats, data.contents);
+	                        });
+	                    }
+	                };
+	                finalInputFileSystem._writeVirtualFile = (file, stats, contents) => {
+	                    const statStorage = getStatStorage(finalInputFileSystem);
+	                    const fileStorage = getFileStorage(finalInputFileSystem);
+	                    const readDirStorage = getReadDirBackend(finalInputFileSystem);
+	                    const realPathStorage = getRealpathBackend(finalInputFileSystem);
+	                    finalInputFileSystem._virtualFiles = finalInputFileSystem._virtualFiles || {};
+	                    finalInputFileSystem._virtualFiles[file] = { stats: stats, contents: contents };
+	                    setData(statStorage, file, createWebpackData(stats));
+	                    setData(fileStorage, file, createWebpackData(contents));
+	                    const segments = file.split(/[\\/]/);
+	                    let count = segments.length - 1;
+	                    const minCount = segments[0] ? 1 : 0;
+	                    while (count > minCount) {
+	                        const dir = segments.slice(0, count).join(path_1.default.sep) || path_1.default.sep;
+	                        try {
+	                            finalInputFileSystem.readdirSync(dir);
+	                        }
+	                        catch (e) {
+	                            const time = Date.now();
+	                            const dirStats = new virtual_stats_1.VirtualStats({
+	                                dev: 8675309,
+	                                nlink: 0,
+	                                uid: 1000,
+	                                gid: 1000,
+	                                rdev: 0,
+	                                blksize: 4096,
+	                                ino: inode++,
+	                                mode: 16877,
+	                                size: stats.size,
+	                                blocks: Math.floor(stats.size / 4096),
+	                                atime: time,
+	                                mtime: time,
+	                                ctime: time,
+	                                birthtime: time,
+	                            });
+	                            setData(readDirStorage, dir, createWebpackData([]));
+	                            if (realPathStorage) {
+	                                setData(realPathStorage, dir, createWebpackData(dir));
+	                            }
+	                            setData(statStorage, dir, createWebpackData(dirStats));
+	                        }
+	                        let dirData = getData(getReadDirBackend(finalInputFileSystem), dir);
+	                        dirData = dirData[1] || dirData.result;
+	                        const filename = segments[count];
+	                        if (dirData.indexOf(filename) < 0) {
+	                            const files = dirData.concat([filename]).sort();
+	                            setData(getReadDirBackend(finalInputFileSystem), dir, createWebpackData(files));
+	                        }
+	                        else {
+	                            break;
+	                        }
+	                        count--;
+	                    }
+	                };
+	            }
+	        };
+	        const afterResolversHook = () => {
+	            if (this._staticModules) {
+	                for (const [filePath, contents] of Object.entries(this._staticModules)) {
+	                    this.writeModule(filePath, contents);
+	                }
+	                this._staticModules = null;
+	            }
+	        };
+	        const version = typeof compiler.webpack === 'undefined' ? 4 : 5;
+	        const watchRunHook = (watcher, callback) => {
+	            this._watcher = watcher.compiler || watcher;
+	            const virtualFiles = compiler.inputFileSystem._virtualFiles;
+	            const fts = compiler.fileTimestamps;
+	            if (virtualFiles && fts && typeof fts.set === 'function') {
+	                Object.keys(virtualFiles).forEach((file) => {
+	                    const mtime = +virtualFiles[file].stats.mtime;
+	                    fts.set(file, version === 4
+	                        ? mtime
+	                        : {
+	                            safeTime: mtime,
+	                            timestamp: mtime,
+	                        });
+	                });
+	            }
+	            callback();
+	        };
+	        if (compiler.hooks) {
+	            compiler.hooks.afterEnvironment.tap('VirtualModulesPlugin', afterEnvironmentHook);
+	            compiler.hooks.afterResolvers.tap('VirtualModulesPlugin', afterResolversHook);
+	            compiler.hooks.watchRun.tapAsync('VirtualModulesPlugin', watchRunHook);
+	        }
+	        else {
+	            compiler.plugin('after-environment', afterEnvironmentHook);
+	            compiler.plugin('after-resolvers', afterResolversHook);
+	            compiler.plugin('watch-run', watchRunHook);
+	        }
+	    }
+	}
+	lib = VirtualModulesPlugin;
+	
+	return lib;
+}
+
+var libExports = requireLib();
+const VirtualModulesPlugin = /*@__PURE__*/getDefaultExportFromCjs(libExports);
+
+export { VirtualModulesPlugin as V };

package/dist/_chunks/_presets/_all.mjs

@@ -0,0 +1,59 @@
+import { _ as _nitro } from './_nitro.mjs';
+import { _ as _static } from './_static.mjs';
+import { _ as _alwaysdata } from './alwaysdata.mjs';
+import { _ as _awsAmplify } from './aws-amplify.mjs';
+import { _ as _awsLambda } from './aws-lambda.mjs';
+import { _ as _azure } from './azure.mjs';
+import { _ as _bun } from './bun.mjs';
+import { _ as _cleavr } from './cleavr.mjs';
+import { _ as _cloudflare } from './cloudflare.mjs';
+import { _ as _deno } from './deno.mjs';
+import { _ as _digitalocean } from './digitalocean.mjs';
+import { _ as _firebase } from './firebase.mjs';
+import { _ as _flightcontrol } from './flightcontrol.mjs';
+import { _ as _genezio } from './genezio.mjs';
+import { _ as _heroku } from './heroku.mjs';
+import { _ as _iis } from './iis.mjs';
+import { _ as _koyeb } from './koyeb.mjs';
+import { _ as _netlify } from './netlify.mjs';
+import { _ as _node } from './node.mjs';
+import { _ as _platformSh } from './platform.mjs';
+import { _ as _renderCom } from './render.mjs';
+import { _ as _standard } from './standard.mjs';
+import { _ as _stormkit } from './stormkit.mjs';
+import { _ as _vercel } from './vercel.mjs';
+import { _ as _winterjs } from './winterjs.mjs';
+import { _ as _zeabur } from './zeabur.mjs';
+import { _ as _zerops } from './zerops.mjs';
+
+const allPresets = [
+  ..._nitro,
+  ..._static,
+  ..._alwaysdata,
+  ..._awsAmplify,
+  ..._awsLambda,
+  ..._azure,
+  ..._bun,
+  ..._cleavr,
+  ..._cloudflare,
+  ..._deno,
+  ..._digitalocean,
+  ..._firebase,
+  ..._flightcontrol,
+  ..._genezio,
+  ..._heroku,
+  ..._iis,
+  ..._koyeb,
+  ..._netlify,
+  ..._node,
+  ..._platformSh,
+  ..._renderCom,
+  ..._standard,
+  ..._stormkit,
+  ..._vercel,
+  ..._winterjs,
+  ..._zeabur,
+  ..._zerops
+];
+
+export { allPresets as a };

package/dist/_chunks/_presets/_nitro.mjs

@@ -0,0 +1,74 @@
+import { d as defineNitroPreset } from './_utils.mjs';
+import { runtimeDir } from 'nitro/runtime/meta';
+import { j as join } from '../_deps/pathe.mjs';
+
+const baseWorker = defineNitroPreset(
+  {
+    entry: null,
+    // Abstract
+    node: false,
+    minify: true,
+    noExternals: true,
+    rollupConfig: {
+      output: {
+        format: "iife",
+        generatedCode: {
+          symbols: true
+        }
+      }
+    },
+    inlineDynamicImports: true
+    // iffe does not support code-splitting
+  },
+  {
+    name: "base-worker"
+  }
+);
+const worker = [baseWorker];
+
+const nitroDev = defineNitroPreset(
+  {
+    entry: "./_nitro/runtime/nitro-dev",
+    output: {
+      dir: "{{ buildDir }}/dev",
+      serverDir: "{{ buildDir }}/dev",
+      publicDir: "{{ buildDir }}/dev"
+    },
+    handlers: [
+      {
+        route: "/_nitro/tasks/**",
+        lazy: true,
+        handler: join(runtimeDir, "internal/routes/dev-tasks")
+      }
+    ],
+    externals: { noTrace: true },
+    serveStatic: true,
+    inlineDynamicImports: true,
+    // externals plugin limitation
+    sourceMap: true
+  },
+  {
+    name: "nitro-dev",
+    dev: true
+  }
+);
+const dev = [nitroDev];
+
+const nitroPrerender = defineNitroPreset(
+  {
+    entry: "./_nitro/runtime/nitro-prerenderer",
+    serveStatic: true,
+    output: {
+      serverDir: "{{ buildDir }}/prerender"
+    },
+    externals: { noTrace: true }
+  },
+  {
+    name: "nitro-prerender"
+  }
+);
+const prerender = [nitroPrerender];
+
+const _nitro = [...worker, ...dev, ...prerender];
+
+export { _nitro as _ };

package/dist/_chunks/_presets/_resolve.mjs

@@ -0,0 +1,64 @@
+import { r as resolveCompatibilityDatesFromEnv, f as formatCompatibilityDate } from '../_deps/compatx.mjs';
+import { kebabCase } from 'scule';
+import { p } from '../_deps/std-env.mjs';
+import { a as allPresets } from './_all.mjs';
+
+const _stdProviderMap = {
+  aws_amplify: "aws",
+  azure_static: "azure",
+  cloudflare_pages: "cloudflare"
+};
+async function resolvePreset(name, opts = {}) {
+  if (name === ".") {
+    return void 0;
+  }
+  const _name = kebabCase(name) || p;
+  const _compatDates = opts.compatibilityDate ? resolveCompatibilityDatesFromEnv(opts.compatibilityDate) : false;
+  const matches = allPresets.filter((preset2) => {
+    const names = [preset2._meta.name, preset2._meta.stdName, ...preset2._meta.aliases || []].filter(Boolean);
+    if (!names.includes(_name)) {
+      return false;
+    }
+    if (opts.dev && !preset2._meta.dev || !opts.dev && preset2._meta.dev) {
+      return false;
+    }
+    if (_compatDates) {
+      const _date = _compatDates[_stdProviderMap[preset2._meta.stdName]] || _compatDates[preset2._meta.stdName] || _compatDates[preset2._meta.name] || _compatDates.default;
+      if (_date && preset2._meta.compatibilityDate && new Date(preset2._meta.compatibilityDate) > new Date(_date)) {
+        return false;
+      }
+    }
+    return true;
+  }).sort((a, b) => {
+    const aDate = new Date(a._meta.compatibilityDate || 0);
+    const bDate = new Date(b._meta.compatibilityDate || 0);
+    return bDate > aDate ? 1 : -1;
+  });
+  const preset = matches.find(
+    (p) => (p._meta.static || false) === (opts?.static || false)
+  ) || matches[0];
+  if (typeof preset === "function") {
+    return preset();
+  }
+  if (!name && !preset) {
+    return opts?.static ? resolvePreset("static", opts) : resolvePreset("node-server", opts);
+  }
+  if (name && !preset) {
+    const options = allPresets.filter((p) => p._meta.name === name || p._meta.stdName === name || p._meta.aliases?.includes(name)).sort((a, b) => (a._meta.compatibilityDate || 0) > (b._meta.compatibilityDate || 0) ? 1 : -1);
+    if (options.length > 0) {
+      let msg = `Preset "${name}" cannot be resolved with current compatibilityDate: ${formatCompatibilityDate(_compatDates || "")}.
+
+`;
+      for (const option of options) {
+        msg += `
+- ${option._meta.name} (requires compatibilityDate >= ${option._meta.compatibilityDate})`;
+      }
+      const err = new Error(msg);
+      Error.captureStackTrace?.(err, resolvePreset);
+      throw err;
+    }
+  }
+  return preset;
+}
+
+export { resolvePreset as r };

package/dist/_chunks/_presets/_static.mjs

@@ -0,0 +1,69 @@
+import fsp from 'node:fs/promises';
+import { d as defineNitroPreset } from './_utils.mjs';
+import { j as join } from '../_deps/pathe.mjs';
+
+const _static = defineNitroPreset(
+  {
+    static: true,
+    output: {
+      dir: "{{ rootDir }}/.output",
+      publicDir: "{{ output.dir }}/public"
+    },
+    prerender: {
+      crawlLinks: true
+    },
+    commands: {
+      preview: "npx serve ./public"
+    }
+  },
+  {
+    name: "static",
+    static: true
+  }
+);
+const githubPages = defineNitroPreset(
+  {
+    extends: "static",
+    commands: {
+      deploy: "npx gh-pages --dotfiles -d ./public"
+    },
+    prerender: {
+      routes: [
+        "/",
+        // https://docs.github.com/en/pages/getting-started-with-github-pages/creating-a-custom-404-page-for-your-github-pages-site
+        "/404.html"
+      ]
+    },
+    hooks: {
+      async compiled(nitro) {
+        await fsp.writeFile(
+          join(nitro.options.output.publicDir, ".nojekyll"),
+          ""
+        );
+      }
+    }
+  },
+  {
+    name: "github-pages",
+    static: true
+  }
+);
+const gitlabPages = defineNitroPreset(
+  {
+    extends: "static",
+    prerender: {
+      routes: [
+        "/",
+        // https://docs.gitlab.com/ee/user/project/pages/introduction.html#custom-error-codes-pages
+        "/404.html"
+      ]
+    }
+  },
+  {
+    name: "gitlab-pages",
+    static: true
+  }
+);
+const _static$1 = [_static, githubPages, gitlabPages];
+
+export { _static$1 as _ };

package/dist/_chunks/_presets/_types.mjs

@@ -0,0 +1,3 @@
+const presetsWithConfig = ["awsAmplify", "awsLambda", "azure", "cloudflare", "firebase", "netlify", "vercel"];
+
+export { presetsWithConfig as p };

package/dist/_chunks/_presets/_utils.mjs

@@ -0,0 +1,31 @@
+import { presetsDir } from 'nitro/runtime/meta';
+import { resolve } from 'node:path';
+import fsp from 'node:fs/promises';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { d as dirname, a as relative } from '../_deps/pathe.mjs';
+
+function defineNitroPreset(preset, meta) {
+  if (typeof preset !== "function" && preset.entry && preset.entry.startsWith(".")) {
+    preset.entry = resolve(presetsDir, preset.entry);
+  }
+  return { ...preset, _meta: meta };
+}
+
+function prettyPath(p, highlight = true) {
+  p = relative(process.cwd(), p);
+  return highlight ? colors.cyan(p) : p;
+}
+async function writeFile(file, contents, log = false) {
+  await fsp.mkdir(dirname(file), { recursive: true });
+  await fsp.writeFile(
+    file,
+    contents,
+    typeof contents === "string" ? "utf8" : void 0
+  );
+  if (log) {
+    consola.info("Generated", prettyPath(file));
+  }
+}
+
+export { defineNitroPreset as d, writeFile as w };

package/dist/_chunks/_presets/alwaysdata.mjs

@@ -0,0 +1,17 @@
+import { d as defineNitroPreset } from './_utils.mjs';
+
+const alwaysdata = defineNitroPreset(
+  {
+    extends: "node-server",
+    serveStatic: true,
+    commands: {
+      deploy: "rsync -rRt --info=progress2 ./ [account]@ssh-[account].alwaysdata.net:www/my-app"
+    }
+  },
+  {
+    name: "alwaysdata"
+  }
+);
+const _alwaysdata = [alwaysdata];
+
+export { _alwaysdata as _ };