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

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;

package/dist/loaders/utils/match-file.d.ts

@@ -0,0 +1,32 @@
+import type { Loader } from "../types.d.ts";
+/**
+ * Tests whether a file matches a loader's test condition.
+ *
+ * This function handles different types of test conditions that can be
+ * specified in a loader configuration:
+ *
+ * 1. **Function**: Calls the function with the file path
+ * 2. **RegExp**: Uses the RegExp's test method
+ * 3. **undefined/null**: Returns false (no match)
+ * @param file File path to test against the condition
+ * @param condition The test condition from a loader (function, RegExp, or undefined)
+ * @returns True if the file matches the condition, false otherwise
+ * @throws Error if the condition type is invalid/unsupported
+ * @example
+ * ```typescript
+ * // Function-based matching
+ * matchFile('styles.css', (file) => file.endsWith('.css')) // true
+ *
+ * // RegExp-based matching
+ * matchFile('styles.sass', /\.(sass|scss)$/i) // false
+ * matchFile('styles.scss', /\.(sass|scss)$/i) // true
+ *
+ * // No condition (undefined)
+ * matchFile('any-file.txt', undefined) // false
+ *
+ * // Invalid condition throws error
+ * matchFile('file.css', { invalid: 'condition' }) // throws Error
+ * ```
+ */
+declare const matchFile: (file: string, condition: Loader["test"]) => boolean;
+export default matchFile;

package/dist/minifiers/cssnano.d.ts

@@ -1,17 +1,31 @@
-import { Options } from 'cssnano';
-import { M as Minifier } from '../packem_shared/types-CA9pSumu.js';
-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 { Options } from "cssnano";
+import type { Minifier } from "./types.d.ts";
+/**
+ * CSSNano minifier implementation for optimizing CSS content.
+ *
+ * This minifier uses CSSNano, a modular CSS minifier built on PostCSS,
+ * to optimize CSS through various transformations including:
+ * - Removing whitespace and comments
+ * - Merging and deduplicating rules
+ * - Optimizing values and selectors
+ * - Removing unused code
+ * - Converting values to shorter equivalents
+ *
+ * The minifier preserves source maps when available and provides detailed
+ * error messages for debugging minification issues.
+ * @example
+ * ```typescript
+ * // Usage in plugin configuration
+ * {
+ *   minifier: cssnanoMinifier,
+ *   cssnano: {
+ *     preset: ['default', {
+ *       discardComments: { removeAll: true },
+ *       normalizeWhitespace: false
+ *     }]
+ *   }
+ * }
+ * ```
+ */
 declare const cssnanoMinifier: Minifier<Options>;
-
-export = cssnanoMinifier;
+export default cssnanoMinifier;

package/dist/minifiers/lightningcss.d.ts

@@ -1,17 +1,30 @@
-import { M as Minifier, 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 { Minifier } from "./types.d.ts";
+/**
+ * LightningCSS minifier implementation for high-performance CSS optimization.
+ *
+ * This minifier uses LightningCSS, a fast CSS parser and transformer written in Rust,
+ * to optimize CSS with excellent performance characteristics. It provides:
+ * - Ultra-fast parsing and minification
+ * - Browser-specific optimizations based on targets
+ * - Advanced CSS transformations and vendor prefixing
+ * - Built-in support for modern CSS features
+ * - Comprehensive warning system for potential issues
+ *
+ * The minifier automatically converts browserslist targets to LightningCSS format
+ * and reports any warnings encountered during the minification process.
+ * @example
+ * ```typescript
+ * // Usage in plugin configuration
+ * {
+ *   minifier: lightningcssMinifier,
+ *   lightningcss: {
+ *     targets: { chrome: 90 },
+ *     unusedSymbols: ['old-class'],
+ *     errorRecovery: true
+ *   }
+ * }
+ * ```
+ */
 declare const lightningcssMinifier: Minifier<NonNullable<InternalStyleOptions["lightningcss"]>>;
-
-export = lightningcssMinifier;
+export default lightningcssMinifier;

package/dist/minifiers/types.d.ts

@@ -0,0 +1,64 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+import type { LoaderContext } from "../loaders/types.d.ts";
+import type { ExtractedData } from "../types.d.ts";
+/**
+ * Context object provided to minifier handlers during CSS minification.
+ *
+ * Contains build-time information and utilities needed for proper minification:
+ * - Browser compatibility targets for optimization decisions
+ * - Logging system for reporting minification issues
+ */
+type MinifierContext = {
+    /** Browser targets for compatibility-aware minification */
+    readonly browserTargets: string[];
+    /**
+     * Rollup-compatible logger for reporting minification issues.
+     * Provides consistent logging across all plugin operations.
+     */
+    readonly logger: RollupLogger;
+};
+/**
+ * Interface for CSS minification plugins.
+ *
+ * Minifiers are responsible for optimizing CSS content while preserving
+ * functionality and maintaining source maps when available. They receive
+ * extracted CSS data and return optimized versions.
+ * @template Options Configuration options type for the minifier
+ * @example
+ * ```typescript
+ * const myMinifier: Minifier<MyOptions> = {
+ *   name: 'my-minifier',
+ *   async handler(data, sourceMap, options) {
+ *     // Minify CSS content
+ *     const minified = await minifyCss(data.css, options);
+ *
+ *     // Report any warnings
+ *     if (minified.warnings.length > 0) {
+ *       this.logger.warn({ message: `Minification warnings: ${minified.warnings.join(', ')}` });
+ *     }
+ *
+ *     return {
+ *       ...data,
+ *       css: minified.css,
+ *       map: minified.map
+ *     };
+ *   }
+ * };
+ * ```
+ */
+export interface Minifier<Options = Record<string, any>> {
+    /**
+     * Minification handler function.
+     *
+     * Processes CSS content and returns optimized version with updated source maps.
+     * The handler is called with minifier context containing browser targets and warning utilities.
+     * @param data Extracted CSS data to minify
+     * @param sourceMap Source map configuration from loader context
+     * @param options Minifier-specific configuration options
+     * @returns Promise resolving to minified CSS data
+     */
+    handler: (this: MinifierContext, data: ExtractedData, sourceMap: LoaderContext["sourceMap"], options: Options) => Promise<ExtractedData>;
+    /** Unique name identifier for the minifier */
+    name: string;
+}
+export {};

package/dist/packem_shared/concat-WcWAYbOc.js

@@ -0,0 +1,3 @@
+var l=Object.defineProperty;var u=(o,n)=>l(o,"name",{value:n,configurable:!0});import{SourceMapGenerator as p}from"source-map-js";import{m as f}from"./sourcemap-CB6ochh0.js";var g=Object.defineProperty,d=u((o,n)=>g(o,"name",{value:n,configurable:!0}),"u");const j=d(async o=>{const n=new p({file:""}),a=[];let c=0;for await(const{css:s,map:m}of o){a.push(s);const i=f(m),t=i.toObject();if(t){const r=i.toConsumer();if(r&&(r.eachMapping(e=>{n.addMapping({generated:{column:e.generatedColumn,line:c+e.generatedLine},name:e.name,original:{column:e.originalColumn,line:e.originalLine},source:e.source})}),t.sourcesContent))for(const e of t.sources)n.setSourceContent(e,r.sourceContentFor(e,!0))}c+=s.split(`
+`).length}return{css:a.join(`
+`),map:n}},"concat");export{j as default};

package/dist/packem_shared/{cssModulesTypesPlugin-B9_bJo_B.mjs → cssModulesTypesPlugin-CjGroK2y.js}

@@ -1,4 +1,4 @@
-var a=Object.defineProperty;var c=(s,e)=>a(s,"name",{value:e,configurable:!0});import{isAccessible as r,writeFile as m}from"@visulima/fs";import{normalize as p}from"@visulima/path";import{n as l}from"./ensure-auto-modules-BU3xWEjl.mjs";var u=Object.defineProperty,d=c((s,e)=>u(s,"name",{value:e,configurable:!0}),"u");const g=`
+var a=Object.defineProperty;var c=(s,e)=>a(s,"name",{value:e,configurable:!0});import{isAccessible as r,writeFile as m}from"@visulima/fs";import{normalize as p}from"@visulima/path";import{n as l}from"./ensure-auto-modules-BU3xWEjl.js";var u=Object.defineProperty,d=c((s,e)=>u(s,"name",{value:e,configurable:!0}),"u");const g=`
 /* eslint-disable */
 /* prettier-ignore */
 // @ts-nocheck

package/dist/packem_shared/{generate-js-exports-Dqps7nWG.mjs → generate-js-exports-BhS4eLrN.js}

@@ -1,4 +1,4 @@
-var G=Object.defineProperty;var C=(r,s)=>G(r,"name",{value:s,configurable:!0});import{relative as V,basename as P}from"@visulima/path";import R from"./safeId-BN5akJYJ.mjs";var W=Object.defineProperty,w=C((r,s)=>W(r,"name",{value:s,configurable:!0}),"j");const d="css",F=new Set(["abstract","arguments","await","boolean","break","byte","case","catch","char","class","const","continue",d,"debugger","default","delete","do","double","else","enum","eval","export","extends","false","final","finally","float","for","function","goto","if","implements","import","in","instanceof","int","interface","let","long","native","new","null","package","private","protected","public","return","short","static","super","switch","synchronized","this","throw","throws","transient","true","try","typeof","var","void","volatile","while","with","yield"]),D=w(r=>{const s=r.replaceAll(/[^\w$]/g,"_");return F.has(s)?`_${s}`:s},"getClassNameIdentifier"),H=w(({css:r,cssVariableName:s,cwd:l,dts:y,dtsOutput:m,id:j,logger:c,modulesExports:e,modulesVariableName:b,namedExports:$,supportModules:g})=>{const o=[`var ${s} = ${JSON.stringify(r)};`];if($&&Object.keys(e).length>0){const u=typeof $=="function"?$:D;for(const[h,a]of Object.entries(e)){const t=u(h);if(h!==t&&c){const v=l?V(l,j):j;c.warn({message:`Exported \`${h}\` as \`${t}\` in ${v}`})}const n=JSON.stringify(a);o.push(`var ${t} = ${n};`),y&&m.push(`declare const ${t}: ${n};`)}}Object.keys(e).length>0&&o.push(`var ${b} = ${JSON.stringify(e)};`);const p=`
+var G=Object.defineProperty;var C=(r,s)=>G(r,"name",{value:s,configurable:!0});import{relative as V,basename as P}from"@visulima/path";import R from"./safeId-BN5akJYJ.js";var W=Object.defineProperty,w=C((r,s)=>W(r,"name",{value:s,configurable:!0}),"j");const d="css",F=new Set(["abstract","arguments","await","boolean","break","byte","case","catch","char","class","const","continue",d,"debugger","default","delete","do","double","else","enum","eval","export","extends","false","final","finally","float","for","function","goto","if","implements","import","in","instanceof","int","interface","let","long","native","new","null","package","private","protected","public","return","short","static","super","switch","synchronized","this","throw","throws","transient","true","try","typeof","var","void","volatile","while","with","yield"]),D=w(r=>{const s=r.replaceAll(/[^\w$]/g,"_");return F.has(s)?`_${s}`:s},"getClassNameIdentifier"),H=w(({css:r,cssVariableName:s,cwd:l,dts:y,dtsOutput:m,id:j,logger:c,modulesExports:e,modulesVariableName:b,namedExports:$,supportModules:g})=>{const o=[`var ${s} = ${JSON.stringify(r)};`];if($&&Object.keys(e).length>0){const u=typeof $=="function"?$:D;for(const[h,a]of Object.entries(e)){const t=u(h);if(h!==t&&c){const v=l?V(l,j):j;c.warn({message:`Exported \`${h}\` as \`${t}\` in ${v}`})}const n=JSON.stringify(a);o.push(`var ${t} = ${n};`),y&&m.push(`declare const ${t}: ${n};`)}}Object.keys(e).length>0&&o.push(`var ${b} = ${JSON.stringify(e)};`);const p=`
 export default ${g?b:s};
 `;return o.push(p),y&&(m.push(`declare const ${s}: string;`),g&&m.push(`
 interface ModulesExports {

package/dist/packem_shared/getMap-TR-0DXUr.js

@@ -0,0 +1 @@
+import"@visulima/fs";import"@visulima/path";import"source-map-js";import{g as o,m as s,s as i}from"./sourcemap-CB6ochh0.js";export{o as getMap,s as mm,i as stripMap};

package/dist/packem_shared/inferModeOption-9h3Eq6JH.js

@@ -0,0 +1 @@
+var f=Object.defineProperty;var l=(n,r)=>f(n,"name",{value:r,configurable:!0});import p from"./arrayFmt-Dek5cB7m.js";import d from"./loadModule-D20jQQNu.js";var y=Object.defineProperty,o=l((n,r)=>y(n,"name",{value:r,configurable:!0}),"o");const u=["inject","extract","emit","inline"],S=p(u),P=o(n=>{const r=Array.isArray(n)?n:[n];if(r[0]&&!u.includes(r[0]))throw new Error(`Incorrect mode provided, allowed modes are ${S}`);const t=r[0]??"inject";let e=!1,i=!1;return t==="extract"&&(e=r[1]??!0),t==="inject"&&(i=r[1]??!0),{emit:t==="emit",extract:e,inject:i,inline:t==="inline"}},"inferModeOption"),O=o((n,r)=>typeof n=="boolean"?n&&{}:typeof n=="object"?n:r,"inferOption"),j=o(n=>{const r=Array.isArray(n)?n:[n];return r[0]?{content:!0,...r[1],inline:r[0]==="inline"}:!1},"inferSourceMapOption"),b=o((n,r)=>{const t=O(n,{});return r&&typeof t=="object"&&!t.alias&&(t.alias=r),t},"inferHandlerOption"),a=o(async(n,r,t,e)=>{if(typeof n!="string")return n;const i=await d(n,t,e);if(!i)throw new Error(`Unable to load PostCSS ${r} \`${n}\``);return i},"ensurePCSSOption"),h=o(async(n,r,t)=>{if(n===void 0)return[];if(n.length===0)return[];const e=[];for await(const i of n.filter(Boolean)){if(!Array.isArray(i)){e.push(await a(i,"plugin",r,t));continue}const[s,c]=i;c?e.push((await a(s,"plugin",r,t))(c)):e.push(await a(s,"plugin",r,t))}return e},"ensurePCSSPlugins");export{a as ensurePCSSOption,h as ensurePCSSPlugins,b as inferHandlerOption,P as inferModeOption,O as inferOption,j as inferSourceMapOption};

package/dist/packem_shared/loadModule-D20jQQNu.js

@@ -0,0 +1 @@
+var d=Object.defineProperty;var n=(e,t)=>d(e,"name",{value:t,configurable:!0});import{createRequire as c}from"node:module";import{interopDefault as m,loadModule as f}from"mlly";import{resolve as p}from"./resolve-anj9ucIq.js";var g=Object.defineProperty,u=n((e,t)=>g(e,"name",{value:t,configurable:!0}),"a");const o={},R=[".js",".mjs",".cjs",".json"],y=u(async(e,t)=>{try{return t(e)}catch(r){const s=r;if(s.code==="ERR_REQUIRE_ESM")return m(await f(e));throw s}},"loadModuleFromPath"),E=u(async(e,t,r)=>{if(o[e])return o[e];if(o[e]===null)return;const s={baseDirs:[t],caller:"Module loader",extensions:R,symlinks:!1},i=c(import.meta.url);try{const a=p([e,`./${e}`],s);if(a.startsWith("data:")){r.warn({message:`Skipping data URL module: ${e}`,module:e,plugin:"css"}),o[e]=null;return}o[e]=await y(a,i)}catch(a){r.warn({message:`Failed to resolve or load module: ${a instanceof Error?a.message:String(a)}`,module:e,plugin:"css"}),o[e]=null;return}const l=o[e];return l?.default??l},"loadModule");export{E as default};

package/dist/packem_shared/resolve-anj9ucIq.js

@@ -0,0 +1 @@
+var a=Object.defineProperty;var i=(o,e)=>a(o,"name",{value:e,configurable:!0});import{fileURLToPath as m}from"node:url";import{dirname as f}from"@visulima/path";import{ResolverFactory as x}from"oxc-resolver";import d from"./arrayFmt-Dek5cB7m.js";var u=Object.defineProperty,v=i((o,e)=>u(o,"name",{value:e,configurable:!0}),"l");const b=f(m(import.meta.url)),k=v((o,e)=>{const s={baseDirs:[b],caller:"Resolver",extensions:[".mjs",".js",".cjs",".json"],symlinks:!0,...e},c=new x({extensions:s.extensions,symlinks:s.symlinks});for(const n of s.baseDirs)for(const t of o)try{const{error:r,path:l}=c.sync(n,t);if(l)return l;r&&console.debug(r,{context:[{basedir:n,caller:e.caller,extensions:e.extensions,id:t}]})}catch(r){console.debug(r.message,{context:[{basedir:n,caller:e.caller,error:r,extensions:e.extensions,id:t}]})}throw new Error(`${s.caller} could not resolve ${d(o)}`)},"resolve");export{k as resolve};

package/dist/packem_shared/rollupCssPlugin-BxRedPmA.js

@@ -0,0 +1,3 @@
+var Y=Object.defineProperty;var N=(e,s)=>Y(e,"name",{value:s,configurable:!0});import{createFilter as ee}from"@rollup/pluginutils";import{createRollupLogger as se}from"@visulima/packem-share/utils";import{dirname as L,normalize as M,isAbsolute as te,relative as U,resolve as oe,parse as T,join as _,basename as V}from"@visulima/path";import{isRelative as ie}from"@visulima/path/utils";import re from"p-queue";import ne from"./concat-WcWAYbOc.js";import{inferSourceMapOption as ae,inferModeOption as ce,inferHandlerOption as W,inferOption as G,ensurePCSSOption as R,ensurePCSSPlugins as le}from"./inferModeOption-9h3Eq6JH.js";import{m as q}from"./sourcemap-CB6ochh0.js";var de=Object.defineProperty,ue=N((e,s)=>de(e,"name",{value:s,configurable:!0}),"r");const J=ue((e,s)=>{if(!s)return!1;if(typeof s=="function")return s(e);if(typeof s.test=="function")return s.test(e);throw new Error("Invalid condition type")},"matchFile");var pe=Object.defineProperty,fe=N((e,s)=>pe(e,"name",{value:s,configurable:!0}),"a");const me=4,ge=process.env.UV_THREADPOOL_SIZE?Number.parseInt(process.env.UV_THREADPOOL_SIZE,10):me;class he{static{N(this,"g")}static{fe(this,"LoaderManager")}test;loaders=new Map;options;workQueue;logger;constructor({extensions:s,loaders:c,logger:y,options:O}){this.test=S=>s.some(f=>S.toLowerCase().endsWith(f)),c.length>0&&this.add(...c),this.options=O,this.logger=y}add(...s){for(const c of s)this.loaders.has(c.name)||this.loaders.set(c.name,c)}isSupported(s){if(this.test(s))return!0;for(const[,c]of this.loaders)if(J(s,c.test))return!0;return!1}async process(s,c){this.workQueue||(this.workQueue=new re({concurrency:ge-1}));for await(const[y,O]of this.loaders){const S={...c,options:this.options[y]??{}};if(O.alwaysProcess||J(S.id,O.test)){this.logger.debug({message:`Processing ${y} loader for ${S.id}`,plugin:"css"});try{const f=await this.workQueue.add(O.process.bind(S,s));f&&(s={...f,extracted:f.extracted??s.extracted,meta:f.meta??s.meta},this.logger.debug({message:`Completed ${y} loader for ${S.id}`,outputSize:f.code?.length||0,plugin:"css"}))}catch(f){throw this.logger.error({file:S.id,loader:y,message:`Error in ${y} loader for ${S.id}: ${f instanceof Error?f.message:String(f)}`,plugin:"css"}),f}}}return s}}var xe=Object.defineProperty,z=N((e,s)=>xe(e,"name",{value:s,configurable:!0}),"b");const ye=z(async(e,s)=>e.sort((c,y)=>s.indexOf(c.name)-s.indexOf(y.name)),"sortByNameOrder"),Fe=z(async(e,s,c,y,O,S,f,Z,K)=>{const C={...K,...e.alias},B=ee(e.include,e.exclude),E=ae(e.sourceMap),i={...ce(e.mode),autoModules:e.autoModules??!1,dts:e.dts,extensions:e.extensions,namedExports:e.namedExports};let a,I,H=!1;if(e.loaders)for(const r of e.loaders)r.name==="postcss"&&(H=!0);else e.loaders=[];H&&(i.postcss={...e.postcss,config:G(e.postcss?.config,{}),import:W(e.postcss?.import,C),modules:G(e.postcss?.modules,void 0),to:e.postcss?.to,url:W(e.postcss?.url,C)});let b=[];const F=z((r,d)=>{const g=[];for(const o of Object.keys(r)){const u=new Set;let h=[o];do{const $=[];for(const m of h){if(u.has(m))continue;if(I.isSupported(m)){B(m)&&$.push(m);continue}u.add(m);const P=d(m);P&&$.push(...P.importedIds)}h=$}while(h.some($=>!I.isSupported($)));g.push(...h)}return g},"traverseImportedModules");return{augmentChunkHash(r){if(b.length===0)return;const d=F(r.modules,this.getModuleInfo),g=b.filter(o=>d.includes(o.id)).sort((o,u)=>d.lastIndexOf(o.id)-d.lastIndexOf(u.id)).map(o=>`${V(o.id)}:${o.css}`);if(g.length!==0)return g.join(":")},async buildStart(){b=[],a=se(this,"css"),H&&i.postcss&&(e.postcss?.parser&&(i.postcss.parser=await R(e.postcss.parser,"parser",c,a)),e.postcss?.syntax&&(i.postcss.syntax=await R(e.postcss.syntax,"syntax",c,a)),e.postcss?.stringifier&&(i.postcss.stringifier=await R(e.postcss.stringifier,"stringifier",c,a)),e.postcss?.plugins&&(i.postcss.plugins=await le(e.postcss.plugins,c,a))),I=new he({extensions:i.extensions,loaders:await ye(e.loaders||[],["sourcemap","stylus","less","sass","postcss"]),logger:a,options:{...e,...i,alias:C}}),a.info({extract:typeof i.extract=="string"?i.extract:"individual",loaders:e.loaders?.map(r=>r.name)||[],message:"CSS plugin initialized",minify:!!(Z&&e.minifier),namedExports:!!i.namedExports,plugin:"css",sourceMap:!!S}),typeof i.inject=="object"&&i.inject.treeshakeable&&(i.namedExports=!1,a.info({message:"Disabling named exports due to `inject.treeshakeable` option",plugin:"css"}))},async generateBundle(r,d){if(b.length===0||!(r.dir||r.file))return;const g=Object.values(d),o=r.dir??L(r.file),u=g.filter(n=>n.type==="chunk"),h=u.filter(n=>!n.facadeModuleId),$=r.preserveModules?u:u.filter(n=>n.isEntry||n.isDynamicEntry),m=[],P=z(async(n,l)=>{const t=typeof i.extract=="string"?M(i.extract).replace(/^\.[/\\]/,""):M(`${n}.css`);te(t)&&this.error(["Extraction path must be relative to the output directory,",`which is ${U(c,o)}`].join(`
+`)),ie(t)&&this.error(["Extraction path must be nested inside output directory,",`which is ${U(c,o)}`].join(`
+`));const w=b.filter(x=>l.includes(x.id)).sort((x,v)=>l.lastIndexOf(x.id)-l.lastIndexOf(v.id)),D=await ne(w);return{css:D.css,map:q(D.map.toString()).relative(L(oe(o,t))).toString(),name:t}},"getExtractedData"),A=z(n=>{if(r.file)return T(r.file).name;if(r.preserveModules){const{dir:l,name:t}=T(n.fileName);return l?_(l,t):t}return n.name},"getName"),k=[];if(typeof i.extract=="string"){a.debug({message:`Extracting to ${i.extract}`,prefix:"css"});const n=[];for(const t of h){const w=F(t.modules,this.getModuleInfo);k.push(...w),n.push(...w)}for(const t of $)n.push(...F(t.modules,this.getModuleInfo).filter(w=>!k.includes(w)));const l=A(u[0]);m.push([l,n])}else{a.debug({message:"Extracting to individual files",prefix:"css"});for(const n of h){const l=F(n.modules,this.getModuleInfo);if(l.length===0)continue;k.push(...l);const t=A(n);m.push([t,l])}for(const n of $){const l=F(n.modules,this.getModuleInfo).filter(w=>!k.includes(w));if(l.length===0)continue;const t=A(n);m.push([t,l])}}for await(const[n,l]of m){const t=await P(n,l);if(typeof e.onExtract=="function"&&!e.onExtract(t))continue;if(Z&&e.minifier){a.info({message:`Minifying ${t.name} with ${e.minifier.name}`,prefix:"css"});const{css:x,map:v}=await e.minifier.handler.bind({browserTargets:s,logger:a})(t,E,e[e.minifier.name]??{});t.css=x,t.map=v}const w={fileName:t.name,name:t.name,names:[t.name],originalFileName:t.name,originalFileNames:[t.name],source:t.css,type:"asset"},D=this.emitFile(w);if(a.info({chunkIds:l.length,hasSourceMap:!!(t.map&&E),message:`Emitted CSS file: ${t.name}`,plugin:"css",size:t.css.length}),t.map&&E){const x=this.getFileName(D);let v="assert";typeof r.assetFileNames=="string"?v=M(L(r.assetFileNames)):typeof r.assetFileNames=="function"&&(v=M(L(r.assetFileNames(w))));const j=q(t.map).modify(p=>(p.file=V(x),p)).modifySources(p=>{if(p==="<no source>"||v.length<=1)return p;p=`../${p}`;for(const Q of v)Q==="/"&&(p=`../${p}`);return p});if(E.inline)j.modify(p=>E.transform?.(p,M(_(o,x)))),d[x].source+=j.toCommentData(),a.debug({message:`Generated inline source map for ${x}`,plugin:"css"});else{const p=`${x}.map`;j.modify(X=>E.transform?.(X,M(_(o,p)))),this.emitFile({fileName:p,source:j.toString(),type:"asset"});const{base:Q}=T(p);d[x].source+=j.toCommentFile(Q),a.debug({message:`Generated external source map: ${p}`,plugin:"css"})}}}m.length>0&&a.info({filesEmitted:m.length,message:"CSS processing complete",plugin:"css",totalExtracted:b.length,totalSize:m.reduce((n,[,l])=>n+l.length,0)})},name:"rollup-plugin-css",async transform(r,d){if(!B(d)||!I.isSupported(d))return;if(r.replaceAll(/\s/g,"")===""){a.debug({message:`Skipping empty file: ${d}`,plugin:"css"});return}a.info({message:`Processing CSS file: ${d}`,plugin:"css",size:r.length}),typeof e.onImport=="function"&&e.onImport(r,d);const g={alias:C,assets:new Map,autoModules:i.autoModules,browserTargets:s,cwd:c,debug:f,deps:new Set,dts:i.dts,emit:i.emit,environment:O,extensions:i.extensions,extract:i.extract,id:d,inject:i.inject,inline:i.inline,logger:a,namedExports:i.namedExports,options:{},plugin:this,sourceDir:y,sourceMap:E,useSourcemap:S},o=await I.process({code:r},g);a.info({assets:g.assets.size,dependencies:g.deps.size,hasExtracted:!!o.extracted,message:`Processed ${d}`,outputSize:o.code.length,plugin:"css"});for(const u of g.deps)this.addWatchFile(u);for(const[u,h]of g.assets)this.emitFile({fileName:u,source:h,type:"asset"}),a.debug({message:`Emitted asset: ${u}`,plugin:"css",size:h.length});if(o.extracted){const{id:u}=o.extracted;b=b.filter(h=>h.id!==u),b.push(o.extracted),a.debug({cssSize:o.extracted.css.length,hasSourceMap:!!o.extracted.map,message:`Extracted CSS from ${u}`,plugin:"css"})}return{code:o.code,map:E&&o.map?o.map:{mappings:""},meta:{styles:o.meta},moduleSideEffects:o.extracted?!0:void 0}}}},"cssPlugin");export{Fe as default};

package/dist/packem_shared/{sourcemap-DGfgaUBb.mjs → sourcemap-CB6ochh0.js}

@@ -1,3 +1,3 @@
-var m=Object.defineProperty;var a=(e,s)=>m(e,"name",{value:s,configurable:!0});import{isAccessibleSync as u,readFileSync as h}from"@visulima/fs";import{resolve as n,relative as f,normalize as l,isAbsolute as d,dirname as S}from"@visulima/path";import{SourceMapConsumer as g}from"source-map-js";const w=/\[hash(?::(\d+))?\]/,x=/(?<!^|[/\\])(\.[^\s.]+)/,y=/data:[^\n\r;]+(?:;charset=[^\n\r;]+)?;base64,([\d+/A-Za-z]+={0,2})/;var M=Object.defineProperty,t=a((e,s)=>M(e,"name",{value:s,configurable:!0}),"i");const p=/(?:\n|\r\n)?\/\*[#*@]+\s*sourceMappingURL\s*=\s*(\S+)\s*\*+\//g,c=/(?:\n|\r\n)?\/\/[#@]+\s*sourceMappingURL\s*=\s*(\S+)\s*/g;class b{static{a(this,"S")}static{t(this,"MapModifier")}map;constructor(s){if(typeof s=="string")try{this.map=JSON.parse(s)}catch{}else this.map=s}modify(s){return this.map?(s(this.map),this):this}modifySources(s){return this.map?(this.map.sources&&(this.map.sources=this.map.sources.map(r=>s(r))),this):this}resolve(s=process.cwd()){return this.modifySources(r=>r==="<no source>"?r:n(s,r))}relative(s=process.cwd()){return this.modifySources(r=>r==="<no source>"?r:d(r)?f(s,r):l(r))}toObject(){return this.map}toString(){return this.map?JSON.stringify(this.map):this.map}toConsumer(){return this.map?new g(this.map):this.map}toCommentData(){const s=this.toString();return s?`
+var m=Object.defineProperty;var a=(e,s)=>m(e,"name",{value:s,configurable:!0});import{isAccessibleSync as u,readFileSync as h}from"@visulima/fs";import{resolve as n,isAbsolute as f,relative as l,normalize as d,dirname as S}from"@visulima/path";import{SourceMapConsumer as g}from"source-map-js";const w=/\[hash(?::(\d+))?\]/,x=/(?<!^|[/\\])(\.[^\s.]+)/,y=/data:[^\n\r;]+(?:;charset=[^\n\r;]+)?;base64,([\d+/A-Za-z]+={0,2})/;var M=Object.defineProperty,t=a((e,s)=>M(e,"name",{value:s,configurable:!0}),"i");const p=/(?:\n|\r\n)?\/\*[#*@]+\s*sourceMappingURL\s*=\s*(\S+)\s*\*+\//g,c=/(?:\n|\r\n)?\/\/[#@]+\s*sourceMappingURL\s*=\s*(\S+)\s*/g;class b{static{a(this,"S")}static{t(this,"MapModifier")}map;constructor(s){if(typeof s=="string")try{this.map=JSON.parse(s)}catch{}else this.map=s}modify(s){return this.map?(s(this.map),this):this}modifySources(s){return this.map?(this.map.sources&&(this.map.sources=this.map.sources.map(r=>s(r))),this):this}resolve(s=process.cwd()){return this.modifySources(r=>r==="<no source>"?r:n(s,r))}relative(s=process.cwd()){return this.modifySources(r=>r==="<no source>"?r:f(r)?l(s,r):d(r))}toObject(){return this.map}toString(){return this.map?JSON.stringify(this.map):this.map}toConsumer(){return this.map?new g(this.map):this.map}toCommentData(){const s=this.toString();return s?`
 /*# sourceMappingURL=data:application/json;base64,${Buffer.from(s).toString("base64")} */`:""}toCommentFile(s){return this.map?`
 /*# sourceMappingURL=${s} */`:""}}const O=t(async(e,s)=>{const[,r]=p.exec(e)??c.exec(e)??[];if(!r)return;const[,i]=y.exec(r)??[];if(i)return Buffer.from(i,"base64").toString();if(!s)throw new Error("Extracted map detected, but no ID is provided");const o=n(S(s),r);if(u(o))return h(o)},"getMap"),U=t(e=>e.replaceAll(p,"").replaceAll(c,""),"stripMap"),_=t(e=>new b(e),"mm");export{y as D,x as F,w as H,O as g,_ as m,U as s};

package/dist/types.d.ts

@@ -0,0 +1,224 @@
+import type { Options } from "cssnano";
+import type { CustomAtRules, TransformOptions } from "lightningcss";
+import type { AcceptedPlugin, PluginCreator } from "postcss";
+import type { Config as PostCSSConfig } from "postcss-load-config";
+import type { LESSLoaderOptions } from "./loaders/less/types.d.ts";
+import type { ImportOptions } from "./loaders/postcss/import/types.d.ts";
+import type { ModulesOptions } from "./loaders/postcss/modules/index.d.ts";
+import type { UrlOptions } from "./loaders/postcss/url/index.d.ts";
+import type { SassLoaderOptions } from "./loaders/sass/types.d.ts";
+import type { StylusLoaderOptions } from "./loaders/stylus/types.d.ts";
+import type { Loader, SourceMapOptions } from "./loaders/types.d.ts";
+import type { Minifier } from "./minifiers/types.d.ts";
+export type AutoModules = RegExp | boolean | ((id: string) => boolean);
+/** CSS data for extraction */
+export interface ExtractedData {
+    /** CSS */
+    css: string;
+    /** Sourcemap */
+    map?: string;
+    /** Output name for CSS */
+    name: string;
+}
+/** Options for CSS injection */
+export interface InjectOptions {
+    /**
+     * Set attributes of injected `<style>` tag(s)
+     * - ex.: `{"id":"global"}`
+     */
+    attributes?: Record<string, string>;
+    /**
+     * Container for `&lt;style>` tag(s) injection
+     * @default "head"
+     */
+    container?: string;
+    /**
+     * Package method name to use with the package
+     * @default "cssStyleInject"
+     */
+    method?: string;
+    /**
+     * Package to import the CSS injector from
+     * @default "@visulima/css-style-inject"
+     */
+    package?: string;
+    /**
+     * Insert `&lt;style>` tag(s) to the beginning of the container
+     * @default false
+     */
+    prepend?: boolean;
+    /**
+     * Inject CSS into single `&lt;style>` tag only
+     * @default false
+     */
+    singleTag?: boolean;
+    /**
+     * Makes injector treeshakeable,
+     * as it is only called when either classes are referenced directly,
+     * or `inject` function is called from the default export.
+     *
+     * Incompatible with `namedExports` option.
+     */
+    treeshakeable?: boolean;
+}
+export interface InternalStyleOptions extends StyleOptions {
+    /** @see {@link StyleOptions.mode} */
+    emit: boolean;
+    extensions: NonNullable<StyleOptions["extensions"]>;
+    /** @see {@link StyleOptions.mode} */
+    extract: boolean | string;
+    /** @see {@link StyleOptions.mode} */
+    inject: InjectOptions | boolean | ((varname: string, id: string, output: string[]) => string);
+    /** @see {@link StyleOptions.mode} */
+    inline: boolean;
+}
+export type LightningCSSOptions = Omit<TransformOptions<CustomAtRules>, "code" | "cssModules" | "filename" | "minify" | "targets"> & {
+    modules?: TransformOptions<CustomAtRules>["cssModules"] & {
+        /**
+         * 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;
+    };
+};
+/** Options for PostCSS config loader */
+export interface PostCSSConfigLoaderOptions {
+    /**
+     * Context object passed to PostCSS config file
+     */
+    ctx?: Record<string, unknown>;
+    /** Path to PostCSS config file directory */
+    path?: string;
+}
+export interface PostCSSOptions {
+    /**
+     * Enable/disable or pass options for PostCSS config loader.
+     */
+    config?: PostCSSConfigLoaderOptions | false;
+    /**
+     * Enable/disable or pass options for CSS `@import` resolver.
+     */
+    import?: Partial<ImportOptions> | false;
+    /**
+     * Enable/disable or pass options for
+     * [CSS Modules](https://github.com/css-modules/css-modules)
+     * @default false
+     */
+    modules?: ModulesOptions | boolean;
+    /**
+     * Set PostCSS parser, e.g. `sugarss`.
+     * Overrides the one loaded from PostCSS config file, if any.
+     */
+    parser?: PostCSSConfig["parser"] | string;
+    /**
+     * A list of plugins for PostCSS,
+     * which are used before plugins loaded from PostCSS config file, if any.
+     */
+    plugins?: (AcceptedPlugin | string | [PluginCreator<unknown> | string, Record<string, unknown>] | [PluginCreator<unknown> | string] | null | undefined)[] | Record<string, unknown>;
+    /**
+     * Set PostCSS stringifier.
+     * Overrides the one loaded from PostCSS config file, if any.
+     */
+    stringifier?: PostCSSConfig["stringifier"] | string;
+    /**
+     * Set PostCSS syntax.
+     * Overrides the one loaded from PostCSS config file, if any.
+     */
+    syntax?: PostCSSConfig["syntax"] | string;
+    /** `to` option for PostCSS, required for some plugins. */
+    to?: PostCSSConfig["to"];
+    /**
+     * Enable/disable or pass options for CSS URL resolver.
+     */
+    url?: Partial<UrlOptions> | false;
+}
+/** `rollup-plugin-styles`'s full option list */
+export interface StyleOptions {
+    /**
+     * Aliases for URL and import paths
+     * - ex.: `{"foo":"bar"}`
+     */
+    alias?: Record<string, string>;
+    /**
+     * Automatically enable
+     * [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
+     */
+    autoModules?: AutoModules;
+    /**
+     * Options for cssnano minifier
+     */
+    cssnano?: Options;
+    /**
+     * Generate TypeScript declarations files for input style files
+     */
+    dts?: boolean;
+    /** Files to exclude from processing */
+    exclude?: ReadonlyArray<RegExp | string> | RegExp | string | undefined;
+    /**
+     * Plugin will process files ending with these extensions
+     * @default [".css", ".pcss", ".postcss", ".sss"]
+     */
+    extensions?: string[];
+    /** Files to include for processing */
+    include?: ReadonlyArray<RegExp | string> | RegExp | string | undefined;
+    /** Options for Less loader */
+    less?: LESSLoaderOptions;
+    /** Options for LightningCSS */
+    lightningcss?: LightningCSSOptions;
+    /** Array of custom loaders */
+    loaders?: Loader[];
+    /** Enable the css minifier */
+    minifier?: Minifier;
+    /**
+     * Select mode for this plugin:
+     * - `"inject"` *(default)* - Embeds CSS inside JS and injects it into `&lt;head>` at runtime.
+     * You can also pass options for CSS injection.
+     * Alternatively, you can pass your own CSS injector.
+     * - `"extract"` - Extract CSS to the same location where JS file is generated but with `.css` extension.
+     * You can also set extraction path manually,
+     * relative to output dir/output file's basedir,
+     * but not outside of it.
+     * - `"emit"` - Emit pure processed CSS and pass it along the build pipeline.
+     * Useful if you want to preprocess CSS before using it with CSS consuming plugins.
+     * - `"inline"` - Embed CSS directly as strings in JavaScript modules.
+     * Reduces HTTP requests but increases bundle size. Ideal for small CSS files or critical CSS.
+     * @default "inject"
+     */
+    mode?: "emit" | "extract" | "inject" | "inline" | ["extract", string] | ["inject", InjectOptions | ((varname: string, id: string) => string)];
+    /**
+     * Use named exports alongside default export.
+     * You can pass a function to control how exported name is generated.
+     * @default false
+     */
+    namedExports?: boolean | ((name: string) => string);
+    /**
+     * Function which is invoked on CSS file extraction.
+     * Return `boolean` to control if file should be extracted or not.
+     */
+    onExtract?: (data: ExtractedData) => boolean;
+    /**
+     * Function which is invoked on CSS file import,
+     * before any transformations are applied
+     */
+    onImport?: (code: string, id: string) => void;
+    /**
+     * Options for PostCSS
+     */
+    postcss?: PostCSSOptions;
+    /** Options for Sass loader */
+    sass?: SassLoaderOptions;
+    /**
+     * Enable/disable or configure sourcemaps
+     * @default false
+     */
+    sourceMap?: boolean | "inline" | [boolean | "inline", SourceMapOptions] | [boolean | "inline"];
+    /** Options for Stylus loader */
+    stylus?: StylusLoaderOptions;
+}