nitro 3.0.1-alpha.0 → 3.0.1-alpha.2

package/dist/_libs/pkg-types.d.mts

@@ -0,0 +1,23 @@
+import { CompilerOptions, TypeAcquisition } from "typescript";
+
+//#region node_modules/.pnpm/pkg-types@2.3.0/node_modules/pkg-types/dist/index.d.mts
+type StripEnums<T extends Record<string, any>> = { [K in keyof T]: T[K] extends boolean ? T[K] : T[K] extends string ? T[K] : T[K] extends object ? T[K] : T[K] extends Array<any> ? T[K] : T[K] extends undefined ? undefined : any };
+interface TSConfig {
+  compilerOptions?: StripEnums<CompilerOptions>;
+  exclude?: string[];
+  compileOnSave?: boolean;
+  extends?: string | string[];
+  files?: string[];
+  include?: string[];
+  typeAcquisition?: TypeAcquisition;
+  references?: {
+    path: string;
+  }[];
+}
+/**
+ * Defines a TSConfig structure.
+ * @param tsconfig - The contents of `tsconfig.json` as an object. See {@link TSConfig}.
+ * @returns the same `tsconfig.json` object.
+ */
+//#endregion
+export { TSConfig as t };

package/dist/_libs/plugin-alias.mjs

@@ -0,0 +1,66 @@
+import { n as __exportAll } from "../_common.mjs";
+import path from "node:path";
+
+//#region node_modules/.pnpm/@rollup+plugin-alias@6.0.0_rollup@4.55.3/node_modules/@rollup/plugin-alias/dist/index.js
+var dist_exports = /* @__PURE__ */ __exportAll({ default: () => alias });
+function matches(pattern, importee) {
+	if (pattern instanceof RegExp) return pattern.test(importee);
+	if (importee.length < pattern.length) return false;
+	if (importee === pattern) return true;
+	return importee.startsWith(pattern + "/");
+}
+function getEntries({ entries, customResolver }) {
+	if (!entries) return [];
+	const resolverFunctionFromOptions = resolveCustomResolver(customResolver);
+	if (Array.isArray(entries)) return entries.map((entry) => {
+		return {
+			find: entry.find,
+			replacement: entry.replacement,
+			resolverFunction: resolveCustomResolver(entry.customResolver) || resolverFunctionFromOptions
+		};
+	});
+	return Object.entries(entries).map(([key, value]) => {
+		return {
+			find: key,
+			replacement: value,
+			resolverFunction: resolverFunctionFromOptions
+		};
+	});
+}
+function getHookFunction(hook) {
+	if (typeof hook === "function") return hook;
+	if (hook && "handler" in hook && typeof hook.handler === "function") return hook.handler;
+	return null;
+}
+function resolveCustomResolver(customResolver) {
+	if (typeof customResolver === "function") return customResolver;
+	if (customResolver) return getHookFunction(customResolver.resolveId);
+	return null;
+}
+function alias(options = {}) {
+	const entries = getEntries(options);
+	if (entries.length === 0) return {
+		name: "alias",
+		resolveId: () => null
+	};
+	return {
+		name: "alias",
+		async buildStart(inputOptions) {
+			await Promise.all([...Array.isArray(options.entries) ? options.entries : [], options].map(({ customResolver }) => customResolver && getHookFunction(customResolver.buildStart)?.call(this, inputOptions)));
+		},
+		resolveId(importee, importer, resolveOptions) {
+			const matchedEntry = entries.find((entry) => matches(entry.find, importee));
+			if (!matchedEntry) return null;
+			const updatedId = importee.replace(matchedEntry.find, matchedEntry.replacement);
+			if (matchedEntry.resolverFunction) return matchedEntry.resolverFunction.call(this, updatedId, importer, resolveOptions);
+			return this.resolve(updatedId, importer, Object.assign({ skipSelf: true }, resolveOptions)).then((resolved) => {
+				if (resolved) return resolved;
+				if (!path.isAbsolute(updatedId)) this.warn(`rewrote ${importee} to ${updatedId} but was not an absolute path and was not handled by other plugins. This will lead to duplicated modules for the same path. To avoid duplicating modules, you should resolve to an absolute path.`);
+				return { id: updatedId };
+			});
+		}
+	};
+}
+
+//#endregion
+export { dist_exports as n, alias as t };

package/dist/_libs/plugin-inject.mjs

@@ -0,0 +1,135 @@
+import { n as __exportAll } from "../_common.mjs";
+import { S as MagicString, c as walk, i as createFilter, r as attachScopes, s as makeLegalIdentifier } from "../_build/common.mjs";
+import { sep } from "path";
+
+//#region node_modules/.pnpm/@rollup+plugin-inject@5.0.5_rollup@4.55.3/node_modules/@rollup/plugin-inject/dist/es/index.js
+var es_exports = /* @__PURE__ */ __exportAll({ default: () => inject });
+var escape = function(str) {
+	return str.replace(/[-[\]/{}()*+?.\\^$|]/g, "\\$&");
+};
+var isReference = function(node, parent) {
+	if (node.type === "MemberExpression") return !node.computed && isReference(node.object, node);
+	if (node.type === "Identifier") {
+		if (parent.type === "MemberExpression") return parent.computed || node === parent.object;
+		if (parent.type === "Property" && node !== parent.value) return false;
+		if (parent.type === "MethodDefinition") return false;
+		if (parent.type === "ExportSpecifier" && node !== parent.local) return false;
+		if (parent.type === "ImportSpecifier" && node === parent.imported) return false;
+		return true;
+	}
+	return false;
+};
+var flatten = function(startNode) {
+	var parts = [];
+	var node = startNode;
+	while (node.type === "MemberExpression") {
+		parts.unshift(node.property.name);
+		node = node.object;
+	}
+	var name = node.name;
+	parts.unshift(name);
+	return {
+		name,
+		keypath: parts.join(".")
+	};
+};
+function inject(options) {
+	if (!options) throw new Error("Missing options");
+	var filter = createFilter(options.include, options.exclude);
+	var modules = options.modules;
+	if (!modules) {
+		modules = Object.assign({}, options);
+		delete modules.include;
+		delete modules.exclude;
+		delete modules.sourceMap;
+		delete modules.sourcemap;
+	}
+	var modulesMap = new Map(Object.entries(modules));
+	if (sep !== "/") modulesMap.forEach(function(mod, key) {
+		modulesMap.set(key, Array.isArray(mod) ? [mod[0].split(sep).join("/"), mod[1]] : mod.split(sep).join("/"));
+	});
+	var firstpass = new RegExp("(?:" + Array.from(modulesMap.keys()).map(escape).join("|") + ")", "g");
+	var sourceMap = options.sourceMap !== false && options.sourcemap !== false;
+	return {
+		name: "inject",
+		transform: function transform(code, id) {
+			if (!filter(id)) return null;
+			if (code.search(firstpass) === -1) return null;
+			if (sep !== "/") id = id.split(sep).join("/");
+			var ast = null;
+			try {
+				ast = this.parse(code);
+			} catch (err) {
+				this.warn({
+					code: "PARSE_ERROR",
+					message: "rollup-plugin-inject: failed to parse " + id + ". Consider restricting the plugin to particular files via options.include"
+				});
+			}
+			if (!ast) return null;
+			var imports = /* @__PURE__ */ new Set();
+			ast.body.forEach(function(node) {
+				if (node.type === "ImportDeclaration") node.specifiers.forEach(function(specifier) {
+					imports.add(specifier.local.name);
+				});
+			});
+			var scope = attachScopes(ast, "scope");
+			var magicString = new MagicString(code);
+			var newImports = /* @__PURE__ */ new Map();
+			function handleReference(node, name, keypath) {
+				var mod = modulesMap.get(keypath);
+				if (mod && !imports.has(name) && !scope.contains(name)) {
+					if (typeof mod === "string") mod = [mod, "default"];
+					if (mod[0] === id) return false;
+					var hash = keypath + ":" + mod[0] + ":" + mod[1];
+					var importLocalName = name === keypath ? name : makeLegalIdentifier("$inject_" + keypath);
+					if (!newImports.has(hash)) {
+						var modName = mod[0].replace(/[''\\]/g, "\\$&");
+						if (mod[1] === "*") newImports.set(hash, "import * as " + importLocalName + " from '" + modName + "';");
+						else newImports.set(hash, "import { " + mod[1] + " as " + importLocalName + " } from '" + modName + "';");
+					}
+					if (name !== keypath) magicString.overwrite(node.start, node.end, importLocalName, { storeName: true });
+					return true;
+				}
+				return false;
+			}
+			walk(ast, {
+				enter: function enter(node, parent) {
+					if (sourceMap) {
+						magicString.addSourcemapLocation(node.start);
+						magicString.addSourcemapLocation(node.end);
+					}
+					if (node.scope) scope = node.scope;
+					if (node.type === "Property" && node.shorthand && node.value.type === "Identifier") {
+						var name = node.key.name;
+						handleReference(node, name, name);
+						this.skip();
+						return;
+					}
+					if (isReference(node, parent)) {
+						var ref$1 = flatten(node);
+						var name$1 = ref$1.name;
+						var keypath = ref$1.keypath;
+						if (handleReference(node, name$1, keypath)) this.skip();
+					}
+				},
+				leave: function leave(node) {
+					if (node.scope) scope = scope.parent;
+				}
+			});
+			if (newImports.size === 0) return {
+				code,
+				ast,
+				map: sourceMap ? magicString.generateMap({ hires: true }) : null
+			};
+			var importBlock = Array.from(newImports.values()).join("\n\n");
+			magicString.prepend(importBlock + "\n\n");
+			return {
+				code: magicString.toString(),
+				map: sourceMap ? magicString.generateMap({ hires: true }) : null
+			};
+		}
+	};
+}
+
+//#endregion
+export { inject as n, es_exports as t };

package/dist/_libs/plugin-json.mjs

@@ -0,0 +1,36 @@
+import { a as dataToEsm, i as createFilter } from "../_build/common.mjs";
+
+//#region node_modules/.pnpm/@rollup+plugin-json@6.1.0_rollup@4.55.3/node_modules/@rollup/plugin-json/dist/es/index.js
+function json(options) {
+	if (options === void 0) options = {};
+	var filter = createFilter(options.include, options.exclude);
+	var indent = "indent" in options ? options.indent : "	";
+	return {
+		name: "json",
+		transform: function transform(code, id) {
+			if (id.slice(-5) !== ".json" || !filter(id)) return null;
+			try {
+				return {
+					code: dataToEsm(JSON.parse(code), {
+						preferConst: options.preferConst,
+						compact: options.compact,
+						namedExports: options.namedExports,
+						includeArbitraryNames: options.includeArbitraryNames,
+						indent
+					}),
+					map: { mappings: "" }
+				};
+			} catch (err) {
+				this.error({
+					message: "Could not parse JSON file",
+					id,
+					cause: err
+				});
+				return null;
+			}
+		}
+	};
+}
+
+//#endregion
+export { json as t };

package/dist/_libs/pluginutils+plugin-commonjs.d.mts

@@ -0,0 +1,241 @@
+import { Plugin } from "rollup";
+
+//#region node_modules/.pnpm/@rollup+pluginutils@5.3.0_rollup@4.55.3/node_modules/@rollup/pluginutils/types/index.d.ts
+/**
+ * A valid `picomatch` glob pattern, or array of patterns.
+ */
+type FilterPattern = ReadonlyArray<string | RegExp> | string | RegExp | null;
+//#endregion
+//#region node_modules/.pnpm/@rollup+plugin-commonjs@29.0.0_rollup@4.55.3/node_modules/@rollup/plugin-commonjs/types/index.d.ts
+type RequireReturnsDefaultOption = boolean | 'auto' | 'preferred' | 'namespace';
+type DefaultIsModuleExportsOption = boolean | 'auto';
+interface RollupCommonJSOptions {
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should operate on. By default, all files with
+   * extension `".cjs"` or those in `extensions` are included, but you can
+   * narrow this list by only including specific files. These files will be
+   * analyzed and transpiled if either the analysis does not find ES module
+   * specific statements or `transformMixedEsModules` is `true`.
+   * @default undefined
+   */
+  include?: FilterPattern;
+  /**
+   * A picomatch pattern, or array of patterns, which specifies the files in
+   * the build the plugin should _ignore_. By default, all files with
+   * extensions other than those in `extensions` or `".cjs"` are ignored, but you
+   * can exclude additional files. See also the `include` option.
+   * @default undefined
+   */
+  exclude?: FilterPattern;
+  /**
+   * For extensionless imports, search for extensions other than .js in the
+   * order specified. Note that you need to make sure that non-JavaScript files
+   * are transpiled by another plugin first.
+   * @default [ '.js' ]
+   */
+  extensions?: ReadonlyArray<string>;
+  /**
+   * If true then uses of `global` won't be dealt with by this plugin
+   * @default false
+   */
+  ignoreGlobal?: boolean;
+  /**
+   * If false, skips source map generation for CommonJS modules. This will
+   * improve performance.
+   * @default true
+   */
+  sourceMap?: boolean;
+  /**
+   * Some `require` calls cannot be resolved statically to be translated to
+   * imports.
+   * When this option is set to `false`, the generated code will either
+   * directly throw an error when such a call is encountered or, when
+   * `dynamicRequireTargets` is used, when such a call cannot be resolved with a
+   * configured dynamic require target.
+   * Setting this option to `true` will instead leave the `require` call in the
+   * code or use it as a fallback for `dynamicRequireTargets`.
+   * @default false
+   */
+  ignoreDynamicRequires?: boolean;
+  /**
+   * Instructs the plugin whether to enable mixed module transformations. This
+   * is useful in scenarios with modules that contain a mix of ES `import`
+   * statements and CommonJS `require` expressions. Set to `true` if `require`
+   * calls should be transformed to imports in mixed modules, or `false` if the
+   * `require` expressions should survive the transformation. The latter can be
+   * important if the code contains environment detection, or you are coding
+   * for an environment with special treatment for `require` calls such as
+   * ElectronJS. See also the `ignore` option.
+   * @default false
+   */
+  transformMixedEsModules?: boolean;
+  /**
+   * By default, this plugin will try to hoist `require` statements as imports
+   * to the top of each file. While this works well for many code bases and
+   * allows for very efficient ESM output, it does not perfectly capture
+   * CommonJS semantics as the order of side effects like log statements may
+   * change. But it is especially problematic when there are circular `require`
+   * calls between CommonJS modules as those often rely on the lazy execution of
+   * nested `require` calls.
+   *
+   * Setting this option to `true` will wrap all CommonJS files in functions
+   * which are executed when they are required for the first time, preserving
+   * NodeJS semantics. Note that this can have an impact on the size and
+   * performance of the generated code.
+   *
+   * The default value of `"auto"` will only wrap CommonJS files when they are
+   * part of a CommonJS dependency cycle, e.g. an index file that is required by
+   * many of its dependencies. All other CommonJS files are hoisted. This is the
+   * recommended setting for most code bases.
+   *
+   * `false` will entirely prevent wrapping and hoist all files. This may still
+   * work depending on the nature of cyclic dependencies but will often cause
+   * problems.
+   *
+   * You can also provide a picomatch pattern, or array of patterns, to only
+   * specify a subset of files which should be wrapped in functions for proper
+   * `require` semantics.
+   *
+   * `"debug"` works like `"auto"` but after bundling, it will display a warning
+   * containing a list of ids that have been wrapped which can be used as
+   * picomatch pattern for fine-tuning.
+   * @default "auto"
+   */
+  strictRequires?: boolean | FilterPattern;
+  /**
+   * Sometimes you have to leave require statements unconverted. Pass an array
+   * containing the IDs or a `id => boolean` function.
+   * @default []
+   */
+  ignore?: ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * In most cases, where `require` calls are inside a `try-catch` clause,
+   * they should be left unconverted as it requires an optional dependency
+   * that may or may not be installed beside the rolled up package.
+   * Due to the conversion of `require` to a static `import` - the call is
+   * hoisted to the top of the file, outside the `try-catch` clause.
+   *
+   * - `true`: Default. All `require` calls inside a `try` will be left unconverted.
+   * - `false`: All `require` calls inside a `try` will be converted as if the
+   *   `try-catch` clause is not there.
+   * - `remove`: Remove all `require` calls from inside any `try` block.
+   * - `string[]`: Pass an array containing the IDs to left unconverted.
+   * - `((id: string) => boolean|'remove')`: Pass a function that controls
+   *   individual IDs.
+   *
+   * @default true
+   */
+  ignoreTryCatch?: boolean | 'remove' | ReadonlyArray<string> | ((id: string) => boolean | 'remove');
+  /**
+   * Controls how to render imports from external dependencies. By default,
+   * this plugin assumes that all external dependencies are CommonJS. This
+   * means they are rendered as default imports to be compatible with e.g.
+   * NodeJS where ES modules can only import a default export from a CommonJS
+   * dependency.
+   *
+   * If you set `esmExternals` to `true`, this plugin assumes that all
+   * external dependencies are ES modules and respect the
+   * `requireReturnsDefault` option. If that option is not set, they will be
+   * rendered as namespace imports.
+   *
+   * You can also supply an array of ids to be treated as ES modules, or a
+   * function that will be passed each external id to determine whether it is
+   * an ES module.
+   * @default false
+   */
+  esmExternals?: boolean | ReadonlyArray<string> | ((id: string) => boolean);
+  /**
+   * Controls what is returned when requiring an ES module from a CommonJS file.
+   * When using the `esmExternals` option, this will also apply to external
+   * modules. By default, this plugin will render those imports as namespace
+   * imports i.e.
+   *
+   * ```js
+   * // input
+   * const foo = require('foo');
+   *
+   * // output
+   * import * as foo from 'foo';
+   * ```
+   *
+   * However, there are some situations where this may not be desired.
+   * For these situations, you can change Rollup's behaviour either globally or
+   * per module. To change it globally, set the `requireReturnsDefault` option
+   * to one of the following values:
+   *
+   * - `false`: This is the default, requiring an ES module returns its
+   *   namespace. This is the only option that will also add a marker
+   *   `__esModule: true` to the namespace to support interop patterns in
+   *   CommonJS modules that are transpiled ES modules.
+   * - `"namespace"`: Like `false`, requiring an ES module returns its
+   *   namespace, but the plugin does not add the `__esModule` marker and thus
+   *   creates more efficient code. For external dependencies when using
+   *   `esmExternals: true`, no additional interop code is generated.
+   * - `"auto"`: This is complementary to how `output.exports: "auto"` works in
+   *   Rollup: If a module has a default export and no named exports, requiring
+   *   that module returns the default export. In all other cases, the namespace
+   *   is returned. For external dependencies when using `esmExternals: true`, a
+   *   corresponding interop helper is added.
+   * - `"preferred"`: If a module has a default export, requiring that module
+   *   always returns the default export, no matter whether additional named
+   *   exports exist. This is similar to how previous versions of this plugin
+   *   worked. Again for external dependencies when using `esmExternals: true`,
+   *   an interop helper is added.
+   * - `true`: This will always try to return the default export on require
+   *   without checking if it actually exists. This can throw at build time if
+   *   there is no default export. This is how external dependencies are handled
+   *   when `esmExternals` is not used. The advantage over the other options is
+   *   that, like `false`, this does not add an interop helper for external
+   *   dependencies, keeping the code lean.
+   *
+   * To change this for individual modules, you can supply a function for
+   * `requireReturnsDefault` instead. This function will then be called once for
+   * each required ES module or external dependency with the corresponding id
+   * and allows you to return different values for different modules.
+   * @default false
+   */
+  requireReturnsDefault?: RequireReturnsDefaultOption | ((id: string) => RequireReturnsDefaultOption);
+  /**
+   * @default "auto"
+   */
+  defaultIsModuleExports?: DefaultIsModuleExportsOption | ((id: string) => DefaultIsModuleExportsOption);
+  /**
+   * Some modules contain dynamic `require` calls, or require modules that
+   * contain circular dependencies, which are not handled well by static
+   * imports. Including those modules as `dynamicRequireTargets` will simulate a
+   * CommonJS (NodeJS-like) environment for them with support for dynamic
+   * dependencies. It also enables `strictRequires` for those modules.
+   *
+   * Note: In extreme cases, this feature may result in some paths being
+   * rendered as absolute in the final bundle. The plugin tries to avoid
+   * exposing paths from the local machine, but if you are `dynamicRequirePaths`
+   * with paths that are far away from your project's folder, that may require
+   * replacing strings like `"/Users/John/Desktop/foo-project/"` -> `"/"`.
+   */
+  dynamicRequireTargets?: string | ReadonlyArray<string>;
+  /**
+   * To avoid long paths when using the `dynamicRequireTargets` option, you can use this option to specify a directory
+   * that is a common parent for all files that use dynamic require statements. Using a directory higher up such as `/`
+   * may lead to unnecessarily long paths in the generated code and may expose directory names on your machine like your
+   * home directory name. By default, it uses the current working directory.
+   */
+  dynamicRequireRoot?: string;
+  /**
+   * When enabled, external Node built-ins (e.g., `node:fs`) required from wrapped CommonJS modules
+   * will use `createRequire(import.meta.url)` instead of being hoisted as ESM imports. This prevents
+   * eager loading of Node built-ins at module initialization time.
+   *
+   * Note: This option adds a dependency on `node:module` in the output, which may not be available
+   * in some environments like edge runtimes (Cloudflare Workers, Vercel Edge Runtime).
+   *
+   * @default false
+   */
+  requireNodeBuiltins?: boolean;
+}
+/**
+ * Convert CommonJS modules to ES6, so they can be included in a Rollup bundle
+ */
+declare function commonjs(options?: RollupCommonJSOptions): Plugin;
+//#endregion
+export { commonjs as t };