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

package/CHANGELOG.md

@@ -1,3 +1,21 @@
+## @visulima/rollup-plugin-css [1.0.0-alpha.32](https://github.com/visulima/packem/compare/@visulima/rollup-plugin-css@1.0.0-alpha.31...@visulima/rollup-plugin-css@1.0.0-alpha.32) (2026-04-23)
+
+
+### Dependencies
+
+* **@visulima/packem-share:** upgraded to 1.0.0-alpha.33
+
+## @visulima/rollup-plugin-css [1.0.0-alpha.31](https://github.com/visulima/packem/compare/@visulima/rollup-plugin-css@1.0.0-alpha.30...@visulima/rollup-plugin-css@1.0.0-alpha.31) (2026-04-23)
+
+### Miscellaneous Chores
+
+* **rollup-plugin-css:** restore isolatedDeclarationTransformer and annotate POSTCSS_EXTENSIONS ([5a0752e](https://github.com/visulima/packem/commit/5a0752ecad1376fe4f693cc00bf4231833842848))
+
+
+### Dependencies
+
+* **@visulima/packem-share:** upgraded to 1.0.0-alpha.32
+
 ## @visulima/rollup-plugin-css [1.0.0-alpha.30](https://github.com/visulima/packem/compare/@visulima/rollup-plugin-css@1.0.0-alpha.29...@visulima/rollup-plugin-css@1.0.0-alpha.30) (2026-04-18)
 
 ### Features

package/dist/css-modules-types.d.ts

@@ -0,0 +1,38 @@
+import type { Plugin } from "rollup";
+import type { StyleOptions } from "./types.d.ts";
+/**
+ * Creates a Rollup plugin that generates TypeScript declaration files for CSS modules.
+ *
+ * This plugin automatically generates `.d.ts` files alongside CSS module files,
+ * providing type safety for CSS class names in TypeScript projects. The generated
+ * declarations include typed exports for all CSS classes found in the modules.
+ *
+ * The plugin:
+ * - Detects CSS modules based on configuration (autoModules, postcss.modules, etc.)
+ * - Extracts type information from processed CSS modules
+ * - Generates TypeScript declaration files with proper exports
+ * - Adds watch file dependencies for proper rebuilds
+ * - Logs generation progress
+ * @param options Style options containing CSS modules configuration
+ * @param rootDirectory Root directory for relative path logging
+ * @returns Rollup plugin for CSS modules type generation
+ * @example
+ * ```typescript
+ * // Plugin usage
+ * const plugin = cssModulesTypesPlugin({
+ *   autoModules: true,
+ *   postcss: {
+ *     modules: {
+ *       include: /\.module\./
+ *     }
+ *   }
+ * }, process.cwd());
+ *
+ * // Generated .d.ts file for styles.module.css:
+ * // declare const button: string;
+ * // declare const header: string;
+ * // export { button, header };
+ * ```
+ */
+declare const cssModulesTypesPlugin: (options: StyleOptions, rootDirectory: string) => Plugin;
+export default cssModulesTypesPlugin;

package/dist/css-plugin.d.ts

@@ -0,0 +1,44 @@
+import type { Environment } from "@visulima/packem-share/types";
+import type { Plugin } from "rollup";
+import type { StyleOptions } from "./types.d.ts";
+/**
+ * Creates the main CSS processing plugin for Rollup.
+ *
+ * This plugin provides comprehensive CSS processing capabilities including:
+ * - Multiple preprocessor support (Sass, Less, Stylus)
+ * - PostCSS processing with plugin ecosystem
+ * - CSS modules with automatic detection
+ * - Source map generation and processing
+ * - CSS injection or extraction modes
+ * - Minification support
+ * - TypeScript declaration generation
+ * - Asset handling and optimization
+ * @param options CSS processing options and loader configurations
+ * @param browserTargets Target browsers for compatibility transformations
+ * @param cwd Current working directory for resolving paths
+ * @param sourceDirectory Source directory for relative path resolution
+ * @param environment Build environment (development/production)
+ * @param useSourcemap Whether to generate source maps
+ * @param debug Enable debug logging and performance monitoring
+ * @param minify Enable CSS minification
+ * @param alias Path aliases for import resolution
+ * @returns Promise resolving to configured Rollup plugin
+ * @example
+ * ```typescript
+ * // Basic usage
+ * const plugin = await cssPlugin({
+ *   mode: 'extract',
+ *   extensions: ['.css', '.scss'],
+ *   postcss: { plugins: [autoprefixer] }
+ * }, ['> 1%'], process.cwd(), 'src', 'development', true, false, false, {});
+ *
+ * // CSS Modules with injection
+ * const plugin = await cssPlugin({
+ *   mode: 'inject',
+ *   autoModules: true,
+ *   namedExports: true
+ * }, ['> 1%'], process.cwd(), 'src', 'production', false, false, true, {});
+ * ```
+ */
+declare const cssPlugin: (options: StyleOptions, browserTargets: string[], cwd: string, sourceDirectory: string, environment: Environment, useSourcemap: boolean, debug: boolean, minify: boolean, alias: Record<string, string>) => Promise<Plugin>;
+export default cssPlugin;

package/dist/index.d.ts

@@ -1,19 +1,40 @@
-import { Plugin } from 'rollup';
-import { S as StyleOptions } from './packem_shared/types-B7InbTq8.js';
-export { A as AutoModules, E as ExtractedData, I as InjectOptions, a as InternalStyleOptions, L as LightningCSSOptions, P as PostCSSConfigLoaderOptions, b as PostCSSOptions } from './packem_shared/types-B7InbTq8.js';
-import { Environment } from '@visulima/packem-share/types';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'source-map-js';
-
-declare const cssModulesTypesPlugin: (options: StyleOptions, rootDirectory: string) => Plugin;
-
-declare const cssPlugin: (options: StyleOptions, browserTargets: string[], cwd: string, sourceDirectory: string, environment: Environment, useSourcemap: boolean, debug: boolean, minify: boolean, alias: Record<string, string>) => Promise<Plugin>;
-
-export { StyleOptions, cssModulesTypesPlugin, cssPlugin as rollupCssPlugin };
+/**
+ * CSS Modules TypeScript declaration generator plugin.
+ *
+ * This plugin generates TypeScript declaration files (.d.ts) for CSS modules,
+ * enabling type-safe CSS class name usage in TypeScript projects. It works
+ * in conjunction with the main CSS plugin to provide a complete CSS modules
+ * development experience.
+ *
+ * Features:
+ * - Automatic .d.ts file generation for CSS modules
+ * - Support for custom naming patterns
+ * - Integration with build tools and IDEs
+ * - Real-time updates during development
+ * @example
+ * ```typescript
+ * // Usage alongside main CSS plugin
+ * import { rollupCssPlugin, cssModulesTypesPlugin } from '@packem/rollup-plugin-css';
+ *
+ * export default {
+ *   plugins: [
+ *     rollupCssPlugin({ modules: true }),
+ *     cssModulesTypesPlugin()
+ *   ]
+ * };
+ * ```
+ * @example
+ * ```typescript
+ * // Generated .d.ts file example
+ * // styles.module.css.d.ts
+ * declare const styles: {
+ *   readonly container: string;
+ *   readonly button: string;
+ *   readonly active: string;
+ * };
+ * export default styles;
+ * ```
+ */
+export { default as cssModulesTypesPlugin } from './css-modules-types.d.ts';
+export { default as rollupCssPlugin } from './css-plugin.d.ts';
+export type * from './types.d.ts';

package/dist/loaders/less/importer.d.ts

@@ -0,0 +1,2 @@
+declare const importer: (alias: Record<string, string>) => Less.Plugin;
+export default importer;

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

@@ -1,16 +1,37 @@
-import { c as Loader, d as LESSLoaderOptions } 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 { LESSLoaderOptions } from "./types.d.ts";
+/**
+ * Less loader for processing Less stylesheets to CSS.
+ *
+ * This loader:
+ * - Compiles Less syntax to standard CSS
+ * - Resolves @import statements and dependencies
+ * - Handles alias resolution for imports
+ * - Tracks file dependencies for watch mode
+ * - Generates source maps for debugging
+ * @example
+ * ```less
+ * // Input Less file
+ * @primary-color: #007acc;
+ *
+ * .button {
+ *   color: @primary-color;
+ *   &:hover {
+ *     opacity: 0.8;
+ *   }
+ * }
+ * ```
+ * @example
+ * ```css
+ * // Output CSS
+ * .button {
+ *   color: #007acc;
+ * }
+ * .button:hover {
+ *   opacity: 0.8;
+ * }
+ * ```
+ */
 declare const loader: Loader<LESSLoaderOptions>;
-
-export { LESSLoaderOptions, loader as default };
+export default loader;
+export type { LESSLoaderOptions } from "./types.d.ts";

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

@@ -0,0 +1,24 @@
+/**
+ * Configuration options for the Less loader.
+ *
+ * Extends the standard Less.Options with additional loader-specific settings.
+ * These options are passed directly to the Less compiler during processing.
+ * @example
+ * ```typescript
+ * const lessOptions: LESSLoaderOptions = {
+ *   // Less compiler options
+ *   math: 'parens-division',
+ *   strictUnits: true,
+ *
+ *   // Custom plugins
+ *   plugins: [myLessPlugin],
+ *
+ *   // Global variables
+ *   globalVars: {
+ *     'primary-color': '#007acc'
+ *   }
+ * };
+ * ```
+ * @see {@link https://lesscss.org/usage/#less-options} Less.js Options Documentation
+ */
+export type LESSLoaderOptions = Less.Options;

package/dist/loaders/lightningcss.d.ts

@@ -1,16 +1,14 @@
-import { c as Loader, L as LightningCSSOptions } 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 { LightningCSSOptions } from "../types.d.ts";
+import type { Loader } from "./types.d.ts";
+/**
+ * LightningCSS loader for processing CSS files with the LightningCSS transformer.
+ *
+ * Supports:
+ * - CSS transformation (vendor prefixes, modern syntax → legacy, etc.)
+ * - CSS modules with deterministic export ordering and composes resolution
+ * - Source map generation
+ * - Browser targets via the shared browserslist config
+ * - TypeScript declaration generation when `dts: true` is set
+ */
 declare const lightningCSSLoader: Loader<LightningCSSOptions>;
-
-export { lightningCSSLoader as default };
+export default lightningCSSLoader;

package/dist/loaders/loader-manager.d.ts

@@ -0,0 +1,78 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { InternalStyleOptions } from "../types.d.ts";
+import type { Loader, LoaderContext, Payload } from "./types.d.ts";
+/**
+ * Configuration options for the LoaderManager.
+ */
+interface LoadersOptions {
+    /** @see {@link InternalStyleOptions.extensions} */
+    extensions: string[];
+    /** Array of loaders to manage */
+    loaders: Loader[];
+    /** Logger instance for debugging and error reporting */
+    logger: RollupLogger;
+    /** Internal style processing options */
+    options: InternalStyleOptions;
+}
+/**
+ * Manages and orchestrates multiple CSS loaders in a processing pipeline.
+ *
+ * The LoaderManager handles:
+ * - Registration and management of multiple loaders
+ * - File type detection and loader matching
+ * - Concurrent processing using a thread pool
+ * - Error handling and logging
+ * - Context management for each loader
+ * @example
+ * ```typescript
+ * const manager = new LoaderManager({
+ *   extensions: ['.css', '.scss'],
+ *   loaders: [sassLoader, postcssLoader],
+ *   logger: rollupLogger,
+ *   options: styleOptions
+ * });
+ *
+ * const result = await manager.process(payload, context);
+ * ```
+ */
+declare class LoaderManager {
+    /** Function to test if a file should be processed based on extensions */
+    private readonly test;
+    /** Map of registered loaders by name */
+    private readonly loaders;
+    /** Internal style processing options */
+    private readonly options;
+    /** Queue for managing concurrent loader processing */
+    private workQueue?;
+    /** Logger instance for debugging and error reporting */
+    private readonly logger;
+    /**
+     * Creates a new LoaderManager instance.
+     * @param options Configuration options for the loader manager
+     */
+    constructor({ extensions, loaders, logger, options }: LoadersOptions);
+    /**
+     * Adds one or more loaders to the manager.
+     * @param loaders Loaders to add to the manager
+     * @template T - Type of loader options
+     */
+    add<T extends Record<string, unknown>>(...loaders: Loader<T>[]): void;
+    /**
+     * Checks if a file is supported by any registered loader.
+     * @param file File path to check
+     * @returns True if the file is supported by at least one loader
+     */
+    isSupported(file: string): boolean;
+    /**
+     * Processes a payload through all applicable loaders in sequence.
+     *
+     * Each loader is executed if it either:
+     * - Has `alwaysProcess` set to true, or
+     * - Has a test that matches the file being processed
+     * @param payload The payload to process
+     * @param context The loader context
+     * @returns The processed payload after all applicable loaders have run
+     */
+    process(payload: Payload, context: LoaderContext): Promise<Payload>;
+}
+export default LoaderManager;

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

@@ -0,0 +1,20 @@
+/**
+ * Default PostCSS file extensions for configuration file detection.
+ *
+ * These extensions are used when searching for PostCSS configuration files
+ * in the project directory hierarchy. Supports both CommonJS and ES module formats.
+ * @example
+ * ```typescript
+ * // Configuration files that will be detected:
+ * // - postcss.config.js
+ * // - postcss.config.mjs
+ * // - postcss.config.cjs
+ * // - .postcssrc.js
+ * // - .postcssrc.mjs
+ * // - .postcssrc.cjs
+ * ```
+ */
+export declare const POSTCSS_EXTENSIONS: string[];
+export declare const HASH_REGEXP: RegExp;
+export declare const FIRST_EXTENSION_REGEXP: RegExp;
+export declare const DATA_URI_REGEXP: RegExp;

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

@@ -0,0 +1,8 @@
+import type { PluginCreator } from "postcss";
+import type { Load } from "./loaders/postcss/icss/load.d.ts";
+interface InteroperableCSSOptions {
+    extensions?: string[];
+    load?: Load;
+}
+declare const plugin: PluginCreator<InteroperableCSSOptions>;
+export default plugin;

package/dist/loaders/postcss/icss/load.d.ts

@@ -0,0 +1,5 @@
+import type { ProcessOptions } from "postcss";
+import type Processor from "postcss/lib/processor";
+declare const load: Load;
+export type Load = (url: string, file: string, extensions: string[], processor: Processor, options?: ProcessOptions) => Promise<Record<string, string>>;
+export default load;

package/dist/loaders/postcss/icss/resolve.d.ts

@@ -0,0 +1,6 @@
+import type { CSSImports } from "icss-utils";
+import type { ProcessOptions } from "postcss";
+import type Processor from "postcss/lib/processor";
+import type { Load } from "./loaders/postcss/icss/load.d.ts";
+declare const resolve: (icssImports: CSSImports, load: Load, file: string, extensions: string[], processor: Processor, options?: ProcessOptions) => Promise<Record<string, string>>;
+export default resolve;

package/dist/loaders/postcss/import/apply-conditions.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Modified copy of https://github.com/csstools/postcss-plugins/blob/main/plugin-packs/postcss-bundler/src/postcss-import/lib/apply-conditions.ts
+ *
+ * MIT No Attribution (MIT-0)
+ * Copyright © CSSTools Contributors
+ */
+import type { AtRule, AtRuleProps } from "postcss";
+import type { Stylesheet } from "./types.d.ts";
+declare const applyConditions: (stylesheet: Stylesheet, atRule: (defaults?: AtRuleProps) => AtRule) => void;
+export default applyConditions;

package/dist/loaders/postcss/import/apply-raws.d.ts

@@ -0,0 +1,3 @@
+import type { Stylesheet } from "./types.d.ts";
+declare const applyRaws: (stylesheet: Stylesheet) => void;
+export default applyRaws;

package/dist/loaders/postcss/import/apply-styles.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Modified copy of https://github.com/csstools/postcss-plugins/blob/main/plugin-packs/postcss-bundler/src/postcss-import/lib/apply-styles.ts
+ *
+ * MIT No Attribution (MIT-0)
+ * Copyright © CSSTools Contributors
+ */
+import type { Document, Root } from "postcss";
+import type { Stylesheet } from "./types.d.ts";
+declare const applyStyles: (stylesheet: Stylesheet, styles: Document | Root) => void;
+export default applyStyles;

package/dist/loaders/postcss/import/constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Modified copy of https://github.com/csstools/postcss-plugins/blob/main/plugin-packs/postcss-bundler/src/postcss-import/lib/names.ts
+ *
+ * MIT No Attribution (MIT-0)
+ * Copyright © CSSTools Contributors
+ */
+export declare const IS_CHARSET_REGEX: RegExp;
+export declare const IS_IMPORT_REGEX: RegExp;
+export declare const IS_URL_REGEX: RegExp;
+export declare const IS_LAYER_REGEX: RegExp;
+export declare const IS_SUPPORTS_REGEX: RegExp;
+export declare const IS_SCOPE_REGEX: RegExp;

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

@@ -0,0 +1,3 @@
+import type { Node } from "postcss";
+export type ImportResolve = (url: string, basedir: string, extensions: string[], atRule: Node) => Promise<string> | string;
+export declare const importResolve: ImportResolve;

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

@@ -0,0 +1,12 @@
+/**
+ * Modified copy of https://github.com/csstools/postcss-plugins/blob/main/plugin-packs/postcss-bundler/src/postcss-import/index.ts
+ *
+ * MIT No Attribution (MIT-0)
+ * Copyright © CSSTools Contributors
+ */
+import type { PluginCreator } from "postcss";
+import type { ImportOptions } from "./types.d.ts";
+declare const plugin: PluginCreator<Partial<ImportOptions & {
+    root: string;
+}>>;
+export default plugin;

package/dist/loaders/postcss/import/parser/parse-at-import.d.ts

@@ -0,0 +1,9 @@
+declare const parseAtImport: (parameters: string) => false | {
+    fullUri: string;
+    layer?: string;
+    media?: string;
+    scope?: string;
+    supports?: string;
+    uri: string;
+};
+export default parseAtImport;

package/dist/loaders/postcss/import/parser/parse-styles.d.ts

@@ -0,0 +1,6 @@
+import type { AtRule, Document, Postcss, Result, Root } from "postcss";
+import type { Condition, ImportOptions, State, Stylesheet } from "../types.d.ts";
+declare const parseStyles: (options: ImportOptions & {
+    root: string;
+}, result: Result, styles: Document | Root, state: State, importingNode: AtRule | undefined, conditions: Condition[], from: string[], postcss: Postcss) => Promise<Stylesheet>;
+export default parseStyles;

package/dist/loaders/postcss/import/parser/parse-stylesheet.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Modified copy of https://github.com/csstools/postcss-plugins/blob/main/plugin-packs/postcss-bundler/src/postcss-import/lib/parse-stylesheet.ts
+ *
+ * MIT No Attribution (MIT-0)
+ * Copyright © CSSTools Contributors
+ */
+import type { AtRule, Document, Result, Root } from "postcss";
+import type { Condition, Stylesheet } from "../types.d.ts";
+declare const parseStylesheet: (result: Result, styles: Document | Root, importingNode: AtRule | undefined, conditions: Condition[], from: string[]) => Stylesheet;
+export default parseStylesheet;

package/dist/loaders/postcss/import/types.d.ts

@@ -0,0 +1,95 @@
+import type { AcceptedPlugin, AtRule, ChildNode, Warning } from "postcss";
+import type { ImportResolve } from "./import-resolve.d.ts";
+export type Condition = {
+    layer?: string;
+    media?: string;
+    scope?: string;
+    supports?: string;
+};
+/** `@import` handler options */
+export interface ImportOptions {
+    /**
+     * Aliases for import paths.
+     * Overrides the global `alias` option.
+     * - ex.: `{"foo":"bar"}`
+     */
+    alias: Record<string, string>;
+    /**
+     * On the debug mode, the file path will be added as a comment in the CSS output.
+     */
+    debug?: boolean;
+    /**
+     * Import files ending with these extensions.
+     * Overrides the global `extensions` option.
+     * @default [".css", ".pcss", ".postcss", ".sss"]
+     */
+    extensions: string[];
+    /**
+     * Only transform imports for which the test function returns `true`. Imports for which the test function returns `false` will be left as is. The function gets the path to import as an
+     * argument and should return a boolean.
+     * @default () => true
+     */
+    filter?: (id: string) => boolean;
+    /**
+     * You can overwrite the default loading way by setting this option. This function gets `(filename, importOptions)` arguments and returns content or promised content.
+     */
+    load: (filename: string, importOptions: ImportOptions) => Promise<string> | string;
+    /**
+     * A list of plugins for PostCSS,
+     * which are used before plugins loaded from PostCSS config file, if any
+     */
+    plugins: AcceptedPlugin[];
+    /**
+     * Provide custom resolver for imports
+     * in place of the default one
+     */
+    resolve: ImportResolve;
+    /**
+     * By default, similar files (based on the same content) are being skipped. It's to optimize output and skip similar files like `normalize.css` for example. If this behavior is not what you
+     * want, just set this option to false to disable it.
+     * @default true
+     */
+    skipDuplicates?: boolean | undefined;
+    /**
+     * By default, css-import warns when an empty file is imported.
+     * Set this option to false to disable this warning.
+     * @default true
+     */
+    warnOnEmpty?: boolean;
+}
+export type ImportStatement = {
+    conditions: Condition[];
+    from: string[];
+    fullUri: string;
+    importingNode: AtRule | undefined;
+    node: AtRule;
+    parent?: Statement;
+    stylesheet?: Stylesheet;
+    type: "import";
+    uri: string;
+};
+export type NodesStatement = {
+    conditions: Condition[];
+    from: string[];
+    importingNode: AtRule | undefined;
+    nodes: ChildNode[];
+    parent?: Statement;
+    type: "nodes";
+};
+export type PreImportStatement = {
+    conditions: Condition[];
+    from: string[];
+    importingNode: AtRule | undefined;
+    node: ChildNode;
+    parent?: Statement;
+    type: "pre-import";
+};
+export type State = {
+    hashFiles: Record<string, Record<string, boolean>>;
+    importedFiles: Record<string, Record<string, boolean>>;
+};
+export type Statement = ImportStatement | NodesStatement | PreImportStatement | Warning;
+export type Stylesheet = {
+    charset?: AtRule;
+    statements: Statement[];
+};

package/dist/loaders/postcss/import/utils/base64-encoded-import.d.ts

@@ -0,0 +1,3 @@
+import type { Condition } from "../types.d.ts";
+declare const base64EncodedConditionalImport: (prelude: string, conditions: Condition[]) => string;
+export default base64EncodedConditionalImport;

package/dist/loaders/postcss/import/utils/data-url.d.ts

@@ -0,0 +1,2 @@
+export declare const isValidDataURL: (url?: string) => boolean;
+export declare const dataURLContents: (url: string) => string;

package/dist/loaders/postcss/import/utils/format-import-prelude.d.ts

@@ -0,0 +1,2 @@
+declare const formatImportPrelude: (layer: string | undefined, media: string | undefined, supports: string | undefined, scope: string | undefined) => string;
+export default formatImportPrelude;

package/dist/loaders/postcss/import/utils/load-content.d.ts

@@ -0,0 +1,2 @@
+declare const loadContent: (filename: string) => string;
+export default loadContent;

package/dist/loaders/postcss/import/utils/process-content.d.ts

@@ -0,0 +1,4 @@
+import type { LazyResult, Postcss, Result } from "postcss";
+import type { ImportOptions } from "../types.d.ts";
+declare const processContent: (result: Result, content: string, filename: string, options: ImportOptions, postcss: Postcss) => Promise<LazyResult>;
+export default processContent;

package/dist/loaders/postcss/import/utils/statement.d.ts

@@ -0,0 +1,6 @@
+import type { Warning } from "postcss";
+import type { ImportStatement, NodesStatement, PreImportStatement, Statement } from "../types.d.ts";
+export declare const isWarning: (stmt: Statement) => stmt is Warning;
+export declare const isNodesStatement: (stmt: Statement) => stmt is NodesStatement;
+export declare const isImportStatement: (stmt: Statement) => stmt is ImportStatement;
+export declare const isPreImportStatement: (stmt: Statement) => stmt is PreImportStatement;