@visulima/rollup-plugin-css 1.0.0-alpha.4 → 1.0.0-alpha.40

package/dist/index.d.ts

@@ -1,20 +1,40 @@
-import { Plugin } from 'rollup';
-import { S as StyleOptions } from './packem_shared/types-CA9pSumu.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-CA9pSumu.js';
-import { Environment } from '@visulima/packem-share/types';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import 'less';
-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/index.js

@@ -0,0 +1 @@
+import{default as e}from"./packem_shared/cssModulesTypesPlugin-CjGroK2y.js";import{default as u}from"./packem_shared/rollupCssPlugin-BxRedPmA.js";export{e as cssModulesTypesPlugin,u as rollupCssPlugin};

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,9 +1,37 @@
-// @ts-ignore
-loader;
-export { LESSLoaderOptions };
-declare namespace loader {
-    export const loader: Loader<LESSLoaderOptions>;
-    import _default = loader;
-    export { _default as default };
-}
-export = loader;
+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 default loader;
+export type { LESSLoaderOptions } from "./types.d.ts";

package/dist/loaders/less/index.js

@@ -0,0 +1 @@
+var c=Object.defineProperty;var l=(s,e)=>c(s,"name",{value:e,configurable:!0});import{dirname as u,normalize as d}from"@visulima/path";import f from"less";import{readFileSync as h}from"@visulima/fs";import{resolveAlias as g}from"@visulima/path/utils";import{resolve as y}from"../../packem_shared/resolve-anj9ucIq.js";import{normalizeUrl as F,getUrlOfPartial as v}from"../../packem_shared/hasModuleSpecifier-DIZeev_W.js";var b=Object.defineProperty,m=l((s,e)=>b(s,"name",{value:e,configurable:!0}),"i");const M=[".less",".css"],x=m((s,e)=>new class extends s.FileManager{supports(){return!0}async loadFile(r,a,t){const i=F(g(r,e)),o=v(i),n={baseDirs:[],caller:"Less importer",extensions:M};Array.isArray(t.paths)&&n.baseDirs.push(...t.paths),n.baseDirs.push(a);const p=y([o,i],n);return{contents:h(p),filename:p}}},"getStylesFileManager"),A=m(s=>({install(e,r){r.addFileManager(x(e,s))}}),"importer"),U={name:"less",async process({code:s,map:e}){const r=[A(this.alias)];this.options.plugins&&r.push(...this.options.plugins);const a=f.render,t=await a(s,{...this.options,filename:this.id,plugins:r,sourceMap:{outputSourceFiles:!0,sourceMapBasepath:u(this.id)}}),i=t.imports;for(const o of i)this.deps.add(d(o));return{code:t.css,map:t.map??e}},test:/\.less$/i};export{U as default};

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,17 +1,14 @@
-import { c as Loader, L as LightningCSSOptions } from '../packem_shared/types-CA9pSumu.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import 'less';
-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;
+export default lightningCSSLoader;

package/dist/loaders/lightningcss.js

@@ -0,0 +1,3 @@
+var p=Object.defineProperty;var d=(i,e)=>p(i,"name",{value:e,configurable:!0});import{transform as l,browserslistToTargets as u}from"lightningcss";import{g as f}from"../packem_shared/generate-js-exports-BhS4eLrN.js";import{n as m}from"../packem_shared/ensure-auto-modules-BU3xWEjl.js";var h=Object.defineProperty,g=d((i,e)=>h(i,"name",{value:e,configurable:!0}),"a");const x=g(i=>{const e={},r=Object.entries(i).sort(([s],[t])=>s<t?-1:s>t?1:0);for(const[s,t]of r){const n=[t.name];for(const a of t.composes)(a.type==="local"||a.type==="global")&&n.push(a.name);e[s]=n.join(" ")}return e},"normalizeModulesExports"),j={name:"lightningcss",async process({code:i,map:e}){let r=!1;typeof this.options.modules=="boolean"?r=this.options.modules:typeof this.options.modules=="object"&&(r=m(this.options.modules.include,this.id)),this.autoModules&&this.options.modules===void 0&&(r=m(this.autoModules,this.id));const s=l({...this.options,code:Buffer.from(i),cssModules:this.options.modules??r,filename:this.id,inputSourceMap:e,minify:!1,sourceMap:!!this.sourceMap,targets:u(this.browserTargets)});s.warnings.length>0&&this.logger.warn({message:`warnings when transforming css:
+${s.warnings.map(c=>c.message).join(`
+`)}`});const t=s.code.toString(),n=s.map?Buffer.from(s.map).toString():void 0,a=s.exports?x(s.exports):{},o=f({css:t,cwd:this.cwd,dts:this.dts,emit:this.emit,extract:this.extract,icssDependencies:[],id:this.id,inject:this.inject,inline:this.inline,logger:this.logger,map:n,modulesExports:a,namedExports:this.namedExports,supportModules:r});return this.extract?{code:o.code,extracted:{css:t,id:this.id,map:n},map:o.map,meta:o.meta,moduleSideEffects:o.moduleSideEffects}:{code:o.code,map:o.map,meta:o.meta,moduleSideEffects:o.moduleSideEffects}},test:/\.css$/i};export{j as default};

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;

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

@@ -1,17 +1,28 @@
-import { c as Loader, a as InternalStyleOptions } from '../../packem_shared/types-CA9pSumu.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import 'less';
-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;
+export default loader;