@visulima/rollup-plugin-css 1.0.0-alpha.30 → 1.0.0-alpha.32

package/dist/loaders/postcss/index.d.ts

@@ -1,16 +1,28 @@
-import { c as Loader, a as InternalStyleOptions } from '../../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { InternalStyleOptions } from "../../types.d.ts";
+import type { Loader } from "../types.d.ts";
+/**
+ * PostCSS loader for processing CSS with PostCSS plugins and CSS modules.
+ *
+ * This loader provides comprehensive CSS processing including:
+ * - PostCSS plugin pipeline execution
+ * - CSS modules support with automatic detection
+ * - Import resolution and dependency tracking
+ * - URL processing and asset handling
+ * - Source map generation and transformation
+ * - JavaScript code generation for CSS injection
+ *
+ * The loader always processes files since PostCSS can handle any CSS content
+ * and provides the base transformation layer for other preprocessors.
+ * @example
+ * ```typescript
+ * // CSS Modules processing
+ * // Input: .button { color: red; }
+ * // Output: JavaScript with hashed class names and CSS injection
+ *
+ * // Regular CSS processing
+ * // Input: @import "normalize.css"; .app { color: blue; }
+ * // Output: Resolved imports and processed CSS
+ * ```
+ */
 declare const loader: Loader<NonNullable<InternalStyleOptions["postcss"]>>;
-
-export { loader as default };
+export default loader;

package/dist/loaders/postcss/load-config.d.ts

@@ -0,0 +1,6 @@
+import type { Environment } from "@visulima/packem-share/types";
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { Result } from "postcss-load-config";
+import type { PostCSSConfigLoaderOptions } from "../../types.d.ts";
+declare const loadConfig: (id: string, cwd: string, environment: Environment, logger: RollupLogger, options?: PostCSSConfigLoaderOptions | false) => Promise<Result>;
+export default loadConfig;

package/dist/loaders/postcss/modules/generate.d.ts

@@ -0,0 +1,11 @@
+/**
+ * For reference, postcss-modules's default:
+ * https://github.com/madyankin/postcss-modules/blob/v6.0.0/src/scoping.js#L41
+ *
+ * FYI LightningCSS recommends hash first for grid compatibility,
+ * https://github.com/parcel-bundler/lightningcss/blob/v1.23.0/website/pages/css-modules.md?plain=1#L237-L238
+ *
+ * but PostCSS CSS Modules doesn't seem to transform Grid names
+ */
+declare const generate: (placeholder?: string) => (local: string, file: string, css: string) => string;
+export default generate;

package/dist/loaders/postcss/modules/index.d.ts

@@ -0,0 +1,35 @@
+import type { Plugin } from "postcss";
+import type Processor from "postcss/lib/processor";
+import type { AutoModules } from "../../../types.d.ts";
+declare const modules: (options: ModulesOptions) => (Plugin | Processor)[];
+/** Options for [CSS Modules](https://github.com/css-modules/css-modules) */
+export interface ModulesOptions {
+    /** Export global classes */
+    exportGlobals?: boolean;
+    /** Fail on wrong order of composition */
+    failOnWrongOrder?: boolean;
+    /**
+     * Placeholder or function for scoped name generation.
+     * Allowed blocks for placeholder:
+     * - `[dir]`: The directory name of the asset.
+     * - `[name]`: The file name of the asset excluding any extension.
+     * - `[local]`: The original value of the selector.
+     * - `[hash(:<num>)]`: A hash based on the name and content of the asset (with optional length).
+     * @default "[name]_[local]__[hash:8]"
+     */
+    generateScopedName?: string | ((name: string, file: string, css: string) => string);
+    /**
+     * Files to include for [CSS Modules](https://github.com/css-modules/css-modules)
+     * for files named `[name].module.[ext]`
+     * (e.g. `foo.module.css`, `bar.module.stylus`),
+     * or pass your own function or regular expression
+     * @default false
+     */
+    include?: AutoModules;
+    /**
+     * Default mode for classes
+     * @default "local"
+     */
+    mode?: "global" | "local" | "pure";
+}
+export default modules;

package/dist/loaders/postcss/noop.d.ts

@@ -0,0 +1,22 @@
+import type { PluginCreator } from "postcss";
+/**
+ * No-operation PostCSS plugin used as a fallback when no other plugins are configured.
+ *
+ * This plugin prevents PostCSS from showing warnings about running without any plugins.
+ * It performs no transformations on the CSS - it simply ensures PostCSS has at least
+ * one plugin to execute, which is required for proper PostCSS operation.
+ *
+ * The plugin is automatically added when:
+ * - No user plugins are configured
+ * - No config file plugins are found
+ * - No built-in plugins (import, url, modules) are enabled
+ * @example
+ * ```typescript
+ * // Used internally when plugins array is empty
+ * if (plugins.length === 0) {
+ *   plugins.push(postcssNoop);
+ * }
+ * ```
+ */
+declare const postcssNoop: PluginCreator<unknown>;
+export default postcssNoop;

package/dist/loaders/postcss/url/generate.d.ts

@@ -0,0 +1,2 @@
+declare const generate: (placeholder: string, file: string, source: Uint8Array) => string;
+export default generate;

package/dist/loaders/postcss/url/index.d.ts

@@ -0,0 +1,46 @@
+import type { PluginCreator } from "postcss";
+import type { UrlResolve } from "./url-resolve.d.ts";
+declare const plugin: PluginCreator<UrlOptions>;
+/** URL handler options */
+export interface UrlOptions {
+    /**
+     * Aliases for URL paths.
+     * Overrides the global `alias` option.
+     * - ex.: `{"foo":"bar"}`
+     */
+    alias?: Record<string, string>;
+    /**
+     * Directory path for outputted CSS assets,
+     * which is not included into resulting URL
+     * @default "."
+     */
+    assetDir?: string | ((original: string, resolved: string, file: string) => string);
+    /**
+     * Enable/disable name generation with hash for outputted CSS assets
+     * or provide your own placeholder with the following blocks:
+     * - `[extname]`: The file extension of the asset including a leading dot, e.g. `.png`.
+     * - `[ext]`: The file extension without a leading dot, e.g. `png`.
+     * - `[hash(:&lt;num>)]`: A hash based on the name and content of the asset (with optional length).
+     * - `[name]`: The file name of the asset excluding any extension.
+     *
+     * Forward slashes / can be used to place files in sub-directories.
+     * @default "assets/[name]-[hash][extname]" ("assets/[name][extname]" if false)
+     */
+    hash?: boolean | string;
+    /**
+     * Inline files instead of copying
+     * @default true for `inject` mode, otherwise false
+     */
+    inline?: boolean;
+    /**
+     * Public Path for URLs in CSS files
+     * @default "./"
+     */
+    publicPath?: string | ((original: string, resolved: string, file: string) => string);
+    /**
+     * Provide custom resolver for URLs
+     * in place of the default one
+     */
+    resolve?: UrlResolve;
+}
+export default plugin;

package/dist/loaders/postcss/url/inline.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Converts a file to a data URI for inline embedding in CSS.
+ *
+ * Creates a data URI that can be used directly in CSS
+ * without requiring a separate file request. All files are encoded
+ * using base64 for consistent behavior.
+ * @param file File path used to determine MIME type
+ * @param source File content as Uint8Array to be encoded
+ * @returns Data URI string optimized for CSS usage
+ * @example
+ * ```ts
+ * inlineFile("image.png", pngBuffer)
+ * // Returns: "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..."
+ *
+ * inlineFile("icon.svg", svgBuffer)
+ * // Returns: "data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDov..."
+ * ```
+ */
+declare const inline: (file: string, source: Uint8Array) => string;
+export default inline;

package/dist/loaders/postcss/url/url-resolve.d.ts

@@ -0,0 +1,12 @@
+/** File resolved by URL resolver */
+export interface UrlFile {
+    /** Absolute path to file */
+    from: string;
+    /** File source */
+    source: Uint8Array;
+    /** Original query extracted from the input path */
+    urlQuery?: string;
+}
+/** URL resolver */
+export type UrlResolve = (inputUrl: string, baseDirectories: string[]) => Promise<UrlFile>;
+export declare const urlResolve: UrlResolve;

package/dist/loaders/postcss/url/utils.d.ts

@@ -0,0 +1,4 @@
+import type { Declaration } from "postcss";
+import type { Node, ParsedValue } from "postcss-value-parser";
+export declare const isDeclWithUrl: (decl: Declaration) => boolean;
+export declare const walkUrls: (parsed: ParsedValue, callback: (url: string, node?: Node) => void) => void;

package/dist/loaders/sass/index.d.ts

@@ -1,17 +1,5 @@
-import { c as Loader, e as SassLoaderOptions } from '../../packem_shared/types-B7InbTq8.js';
-export { f as SassLoaderContext } from '../../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { Loader } from "../types.d.ts";
+import type { SassLoaderOptions } from "./types.d.ts";
 declare const loader: Loader<SassLoaderOptions>;
-
-export { SassLoaderOptions, loader as default };
+export default loader;
+export type { SassLoaderContext, SassLoaderOptions } from "./types.d.ts";

package/dist/loaders/sass/modern/importer.d.ts

@@ -0,0 +1,3 @@
+import type { Importer } from "sass";
+declare const importer: (resourcePath: string, debug: boolean) => Importer<"sync">;
+export default importer;

package/dist/loaders/sass/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Modified copy of https://github.com/webpack-contrib/sass-loader
+ *
+ * MIT License
+ *
+ * Copyright JS Foundation and other contributors
+ */
+import type { Environment } from "@visulima/packem-share/types";
+import type { StringOptions as SassStringOptions } from "sass";
+import type { StringOptions as SassEmbeddedStringOptions } from "sass-embedded";
+export type SassLoaderContext = {
+    environment: Environment;
+    resourcePath: string;
+    rootContext: string;
+};
+export type SassLoaderOptions = {
+    additionalData: string | ((content: string | Buffer, loaderContext: SassLoaderContext) => Promise<string>) | ((content: string | Buffer, loaderContext: SassLoaderContext) => string);
+    implementation?: "sass-embedded" | "sass";
+    warnRuleAsWarning?: boolean;
+} & (Omit<SassEmbeddedStringOptions<"sync">, "charset" | "indentedSyntax"> | Omit<SassStringOptions<"sync">, "charset" | "indentedSyntax">);

package/dist/loaders/sass/utils/get-sass-compiler.d.ts

@@ -0,0 +1,8 @@
+import type * as sass from "sass";
+import type * as sassEmbedded from "sass-embedded";
+declare const getSassCompiler: (implementation: "sass-embedded" | "sass" | undefined) => Promise<((sassOptions: sass.StringOptions<"sync"> & {
+    data: string;
+}) => sass.CompileResult) | ((sassOptions: sassEmbedded.StringOptions<"sync"> & {
+    data: string;
+}) => sassEmbedded.CompileResult)>;
+export default getSassCompiler;

package/dist/loaders/sass/utils/get-sass-options.d.ts

@@ -0,0 +1,7 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { SassLoaderContext, SassLoaderOptions } from "../types.d.ts";
+/**
+ * Derives the sass options from the loader context and normalizes its values with sane defaults.
+ */
+declare const getSassOptions: (loaderContext: SassLoaderContext, logger: RollupLogger, options: SassLoaderOptions, content: string, useSourceMap: boolean) => Promise<SassLoaderOptions>;
+export default getSassOptions;

package/dist/loaders/sass/utils/normalize-source-map.d.ts

@@ -0,0 +1,3 @@
+import type { RawSourceMap } from "source-map-js";
+declare const normalizeSourceMap: (map: RawSourceMap) => RawSourceMap;
+export default normalizeSourceMap;

package/dist/loaders/sass/utils/resolve-syntax.d.ts

@@ -0,0 +1,2 @@
+declare const resolveSyntax: (extension: string) => "css" | "indented" | "scss" | undefined;
+export default resolveSyntax;

package/dist/loaders/sass/utils/sass-error-factory.d.ts

@@ -0,0 +1,15 @@
+type SassError = Error & {
+    column?: number;
+    id: string;
+    line?: number;
+};
+declare const errorFactory: (error: Error & {
+    formatted?: string;
+    span?: {
+        start: {
+            column: number;
+            line: number;
+        };
+    };
+}, file: string) => SassError;
+export default errorFactory;

package/dist/loaders/sourcemap.d.ts

@@ -1,16 +1,25 @@
-import { c as Loader } from '../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { Loader } from "./types.d.ts";
+/**
+ * Source map loader for extracting and processing inline source maps from CSS.
+ *
+ * This loader:
+ * - Extracts inline source maps from CSS comments
+ * - Strips source map comments from the CSS content
+ * - Provides the extracted source map for further processing
+ *
+ * This loader always processes files regardless of file type since source maps
+ * can be present in any CSS content.
+ * @example
+ * ```css
+ * // Input CSS with inline source map
+ * .example { color: red; }
+ * //# sourceMappingURL=data:application/json;base64,...
+ * ```
+ * @example
+ * ```css
+ * // Output CSS with source map stripped
+ * .example { color: red; }
+ * ```
+ */
 declare const loader: Loader;
-
-export { loader as default };
+export default loader;

package/dist/loaders/stylus/index.d.ts

@@ -1,17 +1,8 @@
-import { c as Loader, g as StylusLoaderOptions } from '../../packem_shared/types-B7InbTq8.js';
-export { h as StylusDefinition, i as StylusLoaderContext, j as StylusPlugin } from '../../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { Loader } from "../types.d.ts";
+import type { StylusLoaderOptions } from "./types.d.ts";
+/**
+ * Stylus loader for processing Stylus stylesheets to CSS.
+ */
 declare const loader: Loader<StylusLoaderOptions>;
-
-export { StylusLoaderOptions, loader as default };
+export default loader;
+export type { StylusDefinition, StylusLoaderContext, StylusLoaderOptions, StylusPlugin } from "./types.d.ts";

package/dist/loaders/stylus/types.d.ts

@@ -0,0 +1,87 @@
+import type { Environment } from "@visulima/packem-share/types";
+import type { RenderOptions } from "stylus";
+/**
+ * Minimal context passed to `additionalData` functions.
+ */
+export type StylusLoaderContext = {
+    environment: Environment;
+    resourcePath: string;
+    rootContext: string;
+};
+/**
+ * Stylus plugin: either a function that receives the renderer,
+ * or a module id (string) that resolves to a plugin factory.
+ */
+export type StylusPlugin = string | ((renderer: unknown) => void);
+/**
+ * Definition entry: `[name, value]` or `[name, value, raw]`.
+ */
+export type StylusDefinition = [string, unknown] | [string, unknown, boolean];
+/**
+ * Configuration options for the Stylus loader.
+ *
+ * Extends the standard Stylus RenderOptions with loader-specific functionality.
+ * These options are passed to the Stylus compiler during processing.
+ * @example
+ * ```typescript
+ * const stylusOptions: StylusLoaderOptions = {
+ *   paths: ['./styles', './node_modules'],
+ *   define: { 'primary-color': '#007acc' },
+ *   import: ['nib'],
+ *   use: ['nib'],
+ *   compress: true,
+ * };
+ * ```
+ * @see {@link https://stylus-lang.com/docs/js.html} Stylus.js API Documentation
+ */
+export type StylusLoaderOptions = {
+    /**
+     * Prepends or appends Stylus code to the entry file before compilation.
+     * Useful for injecting shared variables, mixins, or plugin imports.
+     */
+    additionalData?: string | ((content: string, loaderContext: StylusLoaderContext) => Promise<string> | string);
+    /**
+     * Disable stylus internal cache.
+     */
+    disableCache?: boolean;
+    /**
+     * Hoist `@import`/`@charset` at-rules to the top of the file
+     * (maps to stylus `hoist atrules`).
+     */
+    hoistAtrules?: boolean;
+    /**
+     * Custom stylus implementation. Either a module id to import,
+     * or a pre-imported Stylus function.
+     */
+    implementation?: string | ((code: string, options?: unknown) => unknown);
+    /**
+     * Files to pre-import before compiling. Equivalent to calling
+     * `.import()` on the renderer for each entry.
+     */
+    import?: string[];
+    /**
+     * Additional include paths. Equivalent to calling `.include()`
+     * on the renderer for each entry.
+     */
+    include?: string[];
+    /**
+     * Include regular CSS on `@import` (maps to stylus `include css`).
+     */
+    includeCSS?: boolean;
+    /**
+     * Emit comments in the generated CSS indicating the corresponding
+     * stylus line (maps to stylus `linenos`).
+     */
+    lineNumbers?: boolean;
+    /**
+     * Pre-define variables/functions on the renderer.
+     * Accepts either a plain object keyed by name or a list of
+     * `[name, value]` / `[name, value, raw]` tuples.
+     */
+    define?: Record<string, unknown> | StylusDefinition[];
+    /**
+     * Stylus plugins to apply via `.use()`.
+     * Strings are resolved and required relative to the current working directory.
+     */
+    use?: StylusPlugin[];
+} & RenderOptions;

package/dist/loaders/tailwindcss-oxide.d.ts

@@ -1,16 +1,6 @@
-import { c as Loader } from '../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { Loader } from "./types.d.ts";
+/**
+ * Tailwind Oxide loader for processing Tailwind CSS files
+ */
 declare const tailwindcssLoader: Loader;
-
-export { tailwindcssLoader as default };
+export default tailwindcssLoader;

package/dist/loaders/types.d.ts

@@ -0,0 +1,102 @@
+import type { Environment } from "@visulima/packem-share/types";
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { CustomPluginOptions, PluginContext } from "rollup";
+import type { RawSourceMap } from "source-map-js";
+import type { InternalStyleOptions } from "../types.d.ts";
+export interface Extracted {
+    /** CSS */
+    css: string;
+    /** Source file path */
+    id: string;
+    /** Sourcemap */
+    map?: string;
+}
+/**
+ * @param T type of loader's options
+ */
+export interface Loader<T = Record<string, unknown>> {
+    /** Skip testing, always process the file */
+    alwaysProcess?: boolean;
+    /** Name */
+    name: string;
+    /** Function for processing */
+    process: (this: LoaderContext<T>, payload: Payload) => Payload | Promise<Payload>;
+    /**
+     * Test to control if file should be processed.
+     * Also used for plugin's supported files test.
+     */
+    test?: RegExp | ((file: string) => boolean);
+}
+/**
+ * @param T type of loader's options
+ */
+export interface LoaderContext<T = Record<string, unknown>> {
+    readonly alias?: Record<string, string>;
+    /** Assets to emit */
+    readonly assets: Map<string, Uint8Array>;
+    /** @see {@link InternalStyleOptions.autoModules} */
+    readonly autoModules: InternalStyleOptions["autoModules"];
+    /** Browser targets */
+    readonly browserTargets: string[];
+    readonly cwd?: string;
+    readonly debug?: boolean;
+    /** Files to watch */
+    readonly deps: Set<string>;
+    /** @see {@link InternalStyleOptions.dts} */
+    readonly dts: InternalStyleOptions["dts"];
+    /** @see {@link InternalStyleOptions.emit} */
+    readonly emit: InternalStyleOptions["emit"];
+    readonly environment: Environment;
+    /** @see {@link InternalStyleOptions.extensions} */
+    readonly extensions: InternalStyleOptions["extensions"];
+    /** @see {@link InternalStyleOptions.extract} */
+    readonly extract: InternalStyleOptions["extract"];
+    /** Resource path */
+    readonly id: string;
+    /** @see {@link InternalStyleOptions.inject} */
+    readonly inject: InternalStyleOptions["inject"];
+    /** @see {@link InternalStyleOptions.inline} */
+    readonly inline: InternalStyleOptions["inline"];
+    /** Rollup-compatible logger for plugin messages */
+    readonly logger: RollupLogger;
+    /** @see {@link InternalStyleOptions.namedExports} */
+    readonly namedExports: InternalStyleOptions["namedExports"];
+    /**
+     * Type-safe configuration options passed to the loader instance
+     * @default {}
+     */
+    readonly options: T;
+    /** [Plugin's context](https://rollupjs.org/guide/en#plugin-context) */
+    readonly plugin: PluginContext;
+    readonly sourceDir?: string;
+    /** @see {@link InternalStyleOptions.sourceMap} */
+    readonly sourceMap: false | (SourceMapOptions & {
+        inline: boolean;
+    });
+    readonly useSourcemap: boolean;
+}
+export interface Payload {
+    /** File content */
+    code: string;
+    dts?: string;
+    /** Extracted data */
+    extracted?: Extracted;
+    /** Sourcemap */
+    map?: string;
+    /** Additional metadata exposed to other Rollup plugins */
+    meta?: CustomPluginOptions;
+}
+export type PostCSSMeta = {
+    icssDependencies: string[];
+    moduleContents: string;
+    types: string;
+};
+export interface SourceMapOptions {
+    /**
+     * Include sources content
+     * @default true
+     */
+    content?: boolean;
+    /** Function for transforming resulting sourcemap */
+    transform?: (map: RawSourceMap, name?: string) => void;
+}

package/dist/loaders/utils/ensure-auto-modules.d.ts

@@ -0,0 +1,39 @@
+import type { AutoModules } from "../../types.d.ts";
+/**
+ * Determines if CSS modules should be enabled for a given file.
+ *
+ * This function checks various conditions to decide whether CSS modules
+ * processing should be applied to a file:
+ *
+ * 1. If AutoModules is undefined, defaults to true (enable modules)
+ * 2. If AutoModules is a function, calls it with the file ID
+ * 3. If AutoModules is a RegExp, tests it against the file ID
+ * 4. If AutoModules is true, uses the default module file pattern
+ * 5. If AutoModules is false, modules are disabled
+ *
+ * The default pattern matches files with `.module.` in their name,
+ * following the convention used by Vite and other build tools.
+ * @param am AutoModules configuration (function, RegExp, boolean, or undefined)
+ * @param id File identifier/path to test
+ * @returns True if CSS modules should be enabled for this file
+ * @example
+ * ```typescript
+ * // Function-based detection
+ * ensureAutoModules((id) => id.includes('.module.'), 'styles.module.css') // true
+ *
+ * // RegExp-based detection
+ * ensureAutoModules(/\.module\./, 'styles.module.css') // true
+ *
+ * // Boolean enable with default pattern
+ * ensureAutoModules(true, 'styles.module.css') // true
+ * ensureAutoModules(true, 'styles.css') // false
+ *
+ * // Boolean disable
+ * ensureAutoModules(false, 'styles.module.css') // false
+ *
+ * // Undefined defaults to true with pattern check
+ * ensureAutoModules(undefined, 'styles.module.css') // true
+ * ```
+ */
+declare const ensureAutoModules: (am: AutoModules | undefined, id: string) => boolean;
+export default ensureAutoModules;