@visulima/packem 1.3.0 → 1.4.1

package/dist/packem_shared/types-GPTFx90c.d.cts

@@ -0,0 +1,463 @@
+import { RollupAliasOptions } from '@rollup/plugin-alias';
+import { RollupCommonJSOptions } from '@rollup/plugin-commonjs';
+import { RollupJsonOptions } from '@rollup/plugin-json';
+import { RollupNodeResolveOptions } from '@rollup/plugin-node-resolve';
+import { RollupReplaceOptions } from '@rollup/plugin-replace';
+import { RollupWasmOptions } from '@rollup/plugin-wasm';
+import { FilterPattern } from '@rollup/pluginutils';
+import { PackageJson } from '@visulima/package';
+import { Pail } from '@visulima/pail';
+import { TsConfigResult } from '@visulima/tsconfig';
+import { Hookable } from 'hookable';
+import { JitiOptions, Jiti } from 'jiti';
+import { PluginContext, CustomPluginOptions, OutputOptions, RollupOptions, Plugin, RollupBuild, RollupWatcher } from 'rollup';
+import { Options as Options$1 } from 'rollup-plugin-dts';
+import { NodePolyfillsOptions } from 'rollup-plugin-polyfill-node';
+import { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
+import { TypeDocOptions } from 'typedoc';
+import { Options } from 'cssnano';
+import { TransformOptions, CustomAtRules } from 'lightningcss';
+import { Node, AcceptedPlugin, PluginCreator } from 'postcss';
+import { Config } from 'postcss-load-config';
+import { SyncOptions } from 'node-sass';
+import { StringOptions } from 'sass';
+import { StringOptions as StringOptions$1 } from 'sass-embedded';
+import { O as Options$2, E as EsbuildPluginConfig } from './types-BLR6WWv2.cjs';
+import { S as SucrasePluginConfig } from './types-DvWhOdt5.cjs';
+import { S as SwcPluginConfig } from './types-CzGE8V_d.cjs';
+import { RenderOptions } from 'stylus';
+import { RawSourceMap } from 'source-map-js';
+
+interface CJSInteropOptions {
+    addDefaultProperty?: boolean;
+}
+
+type SingleTargetDesc = {
+    dest?: string;
+    exclude?: string[] | string;
+    src: string[] | string;
+};
+type MultipleTargetsDesc = SingleTargetDesc | SingleTargetDesc[] | string[] | string;
+type CopyPluginOptions = {
+    copyOnce?: boolean;
+    exactFileNames?: boolean;
+    flatten?: boolean;
+    targets: MultipleTargetsDesc;
+};
+
+interface LESSLoaderOptions extends Record<string, unknown>, Less.Options {
+}
+
+type ImportResolve = (url: string, basedir: string, extensions: string[], atRule: Node) => string | Promise<string>;
+
+interface ImportOptions {
+    alias: Record<string, string>;
+    debug?: boolean;
+    extensions: string[];
+    filter?: (id: string) => boolean;
+    load: (filename: string, importOptions: ImportOptions) => string | Promise<string>;
+    plugins: AcceptedPlugin[];
+    resolve: ImportResolve;
+    skipDuplicates?: boolean | undefined;
+    warnOnEmpty?: boolean;
+}
+
+interface ModulesOptions {
+    exportGlobals?: boolean;
+    failOnWrongOrder?: boolean;
+    generateScopedName?: string | ((name: string, file: string, css: string) => string);
+    include?: AutoModules;
+    mode?: "global" | "local" | "pure";
+}
+
+interface UrlFile {
+    from: string;
+    source: Uint8Array;
+    urlQuery?: string;
+}
+type UrlResolve = (inputUrl: string, baseDirectories: string[]) => Promise<UrlFile>;
+
+interface UrlOptions {
+    alias?: Record<string, string>;
+    assetDir?: string | ((original: string, resolved: string, file: string) => string);
+    hash?: boolean | string;
+    inline?: boolean;
+    publicPath?: string | ((original: string, resolved: string, file: string) => string);
+    resolve?: UrlResolve;
+}
+
+type SassLoaderContext = {
+    environment: Environment;
+    resourcePath: string;
+    rootContext: string;
+};
+type SassLoaderOptions = {
+    additionalData: string | ((content: string | Buffer, loaderContext: SassLoaderContext) => string) | ((content: string | Buffer, loaderContext: SassLoaderContext) => Promise<string>);
+    implementation?: "sass-embedded" | "sass" | "node-sass";
+    warnRuleAsWarning?: boolean;
+} & (Omit<StringOptions<"sync">, "charset" | "indentedSyntax"> | Omit<StringOptions$1<"sync">, "charset" | "indentedSyntax"> | Omit<SyncOptions, "data" | "sourceMapContents" | "sourceMapEmbed" | "sourceMapRoot" | "outFile">);
+
+interface StylusLoaderOptions extends Record<string, unknown>, RenderOptions {
+}
+
+interface Loader<T = Record<string, unknown>> {
+    alwaysProcess?: boolean;
+    name: string;
+    process: (this: LoaderContext<T>, payload: Payload) => Payload | Promise<Payload>;
+    test?: RegExp | ((file: string) => boolean);
+}
+interface LoaderContext<T = Record<string, unknown>> {
+    readonly alias?: Record<string, string>;
+    readonly assets: Map<string, Uint8Array>;
+    readonly autoModules: InternalStyleOptions["autoModules"];
+    readonly browserTargets: string[];
+    readonly cwd?: string;
+    readonly debug?: boolean;
+    readonly deps: Set<string>;
+    readonly dts: InternalStyleOptions["dts"];
+    readonly emit: InternalStyleOptions["emit"];
+    readonly environment: Environment;
+    readonly extensions: InternalStyleOptions["extensions"];
+    readonly extract: InternalStyleOptions["extract"];
+    readonly id: string;
+    readonly inject: InternalStyleOptions["inject"];
+    logger: Pail;
+    readonly namedExports: InternalStyleOptions["namedExports"];
+    readonly options: T;
+    readonly plugin: PluginContext;
+    readonly sourceDir?: string;
+    readonly sourceMap: false | ({
+        inline: boolean;
+    } & SourceMapOptions);
+    readonly useSourcemap: boolean;
+    readonly warn: PluginContext["warn"];
+}
+interface Extracted {
+    css: string;
+    id: string;
+    map?: string;
+}
+interface Payload {
+    code: string;
+    dts?: string;
+    extracted?: Extracted;
+    map?: string;
+    meta?: CustomPluginOptions;
+}
+interface SourceMapOptions {
+    content?: boolean;
+    transform?: (map: RawSourceMap, name?: string) => void;
+}
+
+type MinifierContext = {
+    readonly browserTargets: string[];
+    readonly warn: PluginContext["warn"];
+};
+interface Minifier<Options = Record<string, any>> {
+    handler: (this: MinifierContext, data: ExtractedData, sourceMap: LoaderContext["sourceMap"], options: Options) => Promise<ExtractedData>;
+    name: string;
+}
+
+interface PostCSSOptions {
+    config?: PostCSSConfigLoaderOptions | false;
+    import?: Partial<ImportOptions> | false;
+    modules?: ModulesOptions | boolean;
+    parser?: Config["parser"] | string;
+    plugins?: Record<string, unknown> | (AcceptedPlugin | string | [string | PluginCreator<unknown>] | [string | PluginCreator<unknown>, Record<string, unknown>] | null | undefined)[];
+    stringifier?: Config["stringifier"] | string;
+    syntax?: Config["syntax"] | string;
+    to?: Config["to"];
+    url?: Partial<UrlOptions> | false;
+}
+type LightningCSSOptions = {
+    modules?: {
+        include?: AutoModules;
+    } & TransformOptions<CustomAtRules>["cssModules"];
+} & Omit<TransformOptions<CustomAtRules>, "filename" | "code" | "minify" | "targets" | "cssModules">;
+interface PostCSSConfigLoaderOptions {
+    ctx?: Record<string, unknown>;
+    path?: string;
+}
+interface InternalStyleOptions extends StyleOptions {
+    emit: boolean;
+    extensions: NonNullable<StyleOptions["extensions"]>;
+    extract: boolean | string;
+    inject: InjectOptions | boolean | ((varname: string, id: string, output: string[]) => string);
+}
+interface ExtractedData {
+    css: string;
+    map?: string;
+    name: string;
+}
+interface InjectOptions {
+    attributes?: Record<string, string>;
+    container?: string;
+    prepend?: boolean;
+    singleTag?: boolean;
+    treeshakeable?: boolean;
+}
+type AutoModules = RegExp | boolean | ((id: string) => boolean);
+interface StyleOptions {
+    alias?: Record<string, string>;
+    autoModules?: AutoModules;
+    cssnano?: Options;
+    dts?: boolean;
+    exclude?: ReadonlyArray<RegExp | string> | RegExp | string | null;
+    extensions?: string[];
+    include?: ReadonlyArray<RegExp | string> | RegExp | string | null;
+    less?: LESSLoaderOptions;
+    lightningcss?: LightningCSSOptions;
+    loaders?: Loader[];
+    minifier?: Minifier;
+    mode?: "emit" | "extract" | "inject" | ["extract", string] | ["inject", InjectOptions | ((varname: string, id: string) => string)];
+    namedExports?: boolean | ((name: string) => string);
+    onExtract?: (data: ExtractedData) => boolean;
+    onImport?: (code: string, id: string) => void;
+    postcss?: PostCSSOptions;
+    sass?: SassLoaderOptions;
+    sourceMap?: boolean | "inline" | [boolean | "inline", SourceMapOptions] | [boolean | "inline"];
+    stylus?: StylusLoaderOptions;
+}
+
+interface EsmShimCjsSyntaxOptions {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+
+type IsolatedDeclarationsOptions = {
+    exclude?: FilterPattern;
+    ignoreErrors?: boolean;
+    include?: FilterPattern;
+};
+
+type JSXRemoveAttributesPlugin = {
+    attributes: string[];
+};
+
+interface LicenseOptions {
+    dependenciesMarker?: string;
+    dependenciesTemplate?: (licenses: string[], dependencyLicenseTexts: string, packageName: string | undefined) => string;
+    dtsMarker?: string;
+    dtsTemplate?: (licenses: string[], dependencyLicenseTexts: string, packageName: string | undefined) => string;
+    path?: string;
+}
+
+type Node10CompatibilityOptions = {
+    typeScriptVersion?: string;
+    writeToPackageJson?: boolean;
+};
+
+interface RawLoaderOptions {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+
+type ShebangOptions = {
+    replace: boolean;
+    shebang: string;
+};
+
+interface PatchTypesOptions {
+    identifierReplacements?: Record<string, Record<string, string>>;
+}
+
+declare class FileCache {
+    #private;
+    constructor(cwd: string, cachePath: string | undefined, hashKey: string, logger: Pail);
+    set isEnabled(value: boolean);
+    has(name: string, subDirectory?: string): boolean;
+    get<R>(name: string, subDirectory?: string): R | undefined;
+    set(name: string, data: object | ArrayBuffer | ArrayBufferView | string | undefined, subDirectory?: string): void;
+    private getFilePath;
+}
+
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+interface RollupDynamicImportVariablesOptions {
+    errorWhenNoFilesFound?: boolean;
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+    warnOnError?: boolean;
+}
+type KillSignal = "SIGKILL" | "SIGTERM";
+type Environment = "production" | "development" | undefined;
+type RollupPlugins = {
+    enforce?: "pre" | "post";
+    plugin: Plugin;
+    type?: "build" | "dts";
+}[];
+interface RollupBuildOptions {
+    alias: RollupAliasOptions | false;
+    cjsInterop?: CJSInteropOptions;
+    commonjs: RollupCommonJSOptions | false;
+    copy?: CopyPluginOptions | false;
+    css?: StyleOptions | false;
+    dts: Options$1;
+    dynamicVars?: RollupDynamicImportVariablesOptions | false;
+    esbuild: Options$2 | false;
+    isolatedDeclarations?: IsolatedDeclarationsOptions;
+    json: RollupJsonOptions | false;
+    jsxRemoveAttributes?: JSXRemoveAttributesPlugin | false;
+    license?: LicenseOptions | false;
+    metafile?: boolean;
+    node10Compatibility?: Node10CompatibilityOptions | false;
+    output?: OutputOptions;
+    patchTypes: PatchTypesOptions | false;
+    plugins?: RollupPlugins;
+    polyfillNode?: NodePolyfillsOptions | false;
+    preserveDirectives?: {
+        directiveRegex?: RegExp;
+        exclude?: FilterPattern;
+        include?: FilterPattern;
+    };
+    preserveDynamicImports?: boolean;
+    raw?: RawLoaderOptions | false;
+    replace: RollupReplaceOptions | false;
+    resolve: RollupNodeResolveOptions | false;
+    shebang?: Partial<ShebangOptions> | false;
+    shim?: EsmShimCjsSyntaxOptions | false;
+    sucrase?: SucrasePluginConfig | false;
+    swc?: SwcPluginConfig | false;
+    treeshake?: RollupOptions["treeshake"];
+    visualizer?: PluginVisualizerOptions | false;
+    wasm?: RollupWasmOptions | false;
+    watch?: RollupOptions["watch"];
+}
+type TypeDocumentOptions = {
+    format?: "inline" | "json" | "markdown" | "html";
+    marker?: string;
+    output?: string;
+    readmePath?: string;
+} & Partial<Omit<TypeDocOptions, "entryPoints" | "out" | "hideGenerator" | "watch" | "preserveWatchOutput">>;
+type Runtime = "react-server" | "react-native" | "edge-light" | "node";
+type BuildEntry = {
+    cjs?: boolean;
+    declaration?: boolean | "compatible" | "node16";
+    environment?: Environment;
+    esm?: boolean;
+    executable?: true;
+    exportKey?: Set<string>;
+    fileAlias?: string;
+    input: string;
+    isGlob?: boolean;
+    name?: string;
+    outDir?: string;
+    runtime?: Runtime;
+};
+interface BuildOptions {
+    alias: Record<string, string>;
+    analyze?: boolean;
+    builder?: Record<string, (context: BuildContext, cachePath: string | undefined, fileCache: FileCache, logged: boolean) => Promise<void>>;
+    browserTargets?: string[];
+    cjsInterop?: boolean;
+    clean: boolean;
+    debug: boolean;
+    declaration?: boolean | "compatible" | "node16" | undefined;
+    dtsOnly?: boolean;
+    emitCJS?: boolean;
+    emitESM?: boolean;
+    entries: BuildEntry[];
+    externals: (RegExp | string)[];
+    failOnWarn?: boolean;
+    fileCache?: boolean;
+    isolatedDeclarationTransformer?: (code: string, id: string) => Promise<IsolatedDeclarationsResult>;
+    jiti: Omit<JitiOptions, "onError" | "transform">;
+    killSignal?: KillSignal;
+    minify?: boolean | undefined;
+    name: string;
+    onSuccess?: string | (() => Promise<void | undefined | (() => void | Promise<void>)>);
+    onSuccessTimeout?: number;
+    outDir: string;
+    rollup: RollupBuildOptions;
+    rootDir: string;
+    sourceDir: string;
+    sourcemap: boolean;
+    transformer: (config: SwcPluginConfig | SucrasePluginConfig | EsbuildPluginConfig) => Plugin;
+    typedoc: TypeDocumentOptions | false;
+    validation?: {
+        packageJson?: {
+            bin?: boolean;
+            dependencies?: boolean;
+            exports?: boolean;
+            files?: boolean;
+            main?: boolean;
+            module?: boolean;
+            name?: boolean;
+            types?: boolean;
+            typesVersions?: boolean;
+        };
+    };
+}
+interface BuildHooks {
+    "build:before": (context: BuildContext) => Promise<void> | void;
+    "build:done": (context: BuildContext) => Promise<void> | void;
+    "build:prepare": (context: BuildContext) => Promise<void> | void;
+    "builder:before": (name: string, context: BuildContext) => Promise<void> | void;
+    "builder:done": (name: string, context: BuildContext) => Promise<void> | void;
+    "rollup:build": (context: BuildContext, build: RollupBuild) => Promise<void> | void;
+    "rollup:done": (context: BuildContext) => Promise<void> | void;
+    "rollup:dts:build": (context: BuildContext, build: RollupBuild) => Promise<void> | void;
+    "rollup:dts:done": (context: BuildContext) => Promise<void> | void;
+    "rollup:dts:options": (context: BuildContext, options: RollupOptions) => Promise<void> | void;
+    "rollup:options": (context: BuildContext, options: RollupOptions) => Promise<void> | void;
+    "rollup:watch": (context: BuildContext, watcher: RollupWatcher) => Promise<void> | void;
+    "typedoc:before": (context: BuildContext) => Promise<void> | void;
+    "typedoc:done": (context: BuildContext) => Promise<void> | void;
+    "validate:before": (context: BuildContext) => Promise<void> | void;
+    "validate:done": (context: BuildContext) => Promise<void> | void;
+}
+type BuildContextBuildEntry = {
+    bytes?: number;
+    chunk?: boolean;
+    chunks?: string[];
+    exports?: string[];
+    modules?: {
+        bytes: number;
+        id: string;
+    }[];
+    path: string;
+    type?: "entry";
+};
+type BuildContextBuildAssetAndChunk = {
+    bytes?: number;
+    chunk?: boolean;
+    chunks?: string[];
+    exports?: string[];
+    modules?: {
+        bytes: number;
+        id: string;
+    }[];
+    path: string;
+    type?: "asset" | "chunk";
+};
+interface InternalBuildOptions extends BuildOptions {
+    transformerName: "esbuild" | "sucrase" | "swc" | undefined;
+}
+interface BuildContext {
+    buildEntries: (BuildContextBuildEntry | BuildContextBuildAssetAndChunk)[];
+    dependencyGraphMap: Map<string, Set<[string, string]>>;
+    environment: Environment;
+    hooks: Hookable<BuildHooks>;
+    jiti: Jiti;
+    logger: Pail;
+    mode: Mode;
+    options: InternalBuildOptions;
+    pkg: PackageJson;
+    tsconfig?: TsConfigResult;
+    usedImports: Set<string>;
+    warnings: Set<string>;
+}
+type BuildPreset = BuildConfig | (() => BuildConfig);
+interface BuildConfig extends DeepPartial<Omit<BuildOptions, "entries">> {
+    entries?: (BuildEntry | string)[];
+    hooks?: Partial<BuildHooks>;
+    preset?: BuildPreset | "auto" | "none" | (NonNullable<unknown> & string);
+}
+type Mode = "build" | "jit" | "watch" | "tsdoc";
+interface IsolatedDeclarationsResult {
+    errors: string[];
+    sourceText: string;
+}
+
+export type { BuildConfig as B, Environment as E, IsolatedDeclarationsResult as I, Loader as L, Mode as M, RollupBuildOptions as R, SassLoaderOptions as S, BuildContext as a, BuildContextBuildAssetAndChunk as b, BuildContextBuildEntry as c, BuildEntry as d, BuildHooks as e, BuildOptions as f, BuildPreset as g, Runtime as h, LESSLoaderOptions as i, InternalStyleOptions as j, StylusLoaderOptions as k, LightningCSSOptions as l, Minifier as m };

package/dist/packem_shared/url-DFE8cAA0.cjs

@@ -0,0 +1 @@
+"use strict";var n=Object.defineProperty;var s=(e,r)=>n(e,"name",{value:r,configurable:!0});const i=require("@visulima/path"),t=require("@visulima/path/utils");var u=Object.defineProperty,a=s((e,r)=>u(e,"name",{value:r,configurable:!0}),"e");const o=a(e=>/^~[\d@A-Z]/i.test(e),"hasModuleSpecifier"),c=a(e=>{const{base:r,dir:l}=i.parse(e);return l?`${i.normalize(l)}/_${r}`:`_${r}`},"getUrlOfPartial"),m=a(e=>o(e)?i.normalize(e.slice(1)):i.isAbsolute(e)||t.isRelative(e)?i.normalize(e):"./"+i.normalize(e),"normalizeUrl");exports.g=c;exports.h=o;exports.n=m;

package/dist/packem_shared/url-I6Jx3crl.mjs

@@ -0,0 +1 @@
+var s=Object.defineProperty;var o=(e,r)=>s(e,"name",{value:r,configurable:!0});import{parse as t,normalize as a,isAbsolute as n}from"@visulima/path";import{isRelative as f}from"@visulima/path/utils";var m=Object.defineProperty,i=o((e,r)=>m(e,"name",{value:r,configurable:!0}),"e");const c=i(e=>/^~[\d@A-Z]/i.test(e),"hasModuleSpecifier"),b=i(e=>{const{base:r,dir:l}=t(e);return l?`${a(l)}/_${r}`:`_${r}`},"getUrlOfPartial"),g=i(e=>c(e)?a(e.slice(1)):n(e)||f(e)?a(e):"./"+a(e),"normalizeUrl");export{b as g,c as h,g as n};

package/dist/rollup/plugins/css/loaders/less/index.cjs

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

package/dist/rollup/plugins/css/loaders/less/index.d.cts

@@ -0,0 +1,36 @@
+import { L as Loader, i as LESSLoaderOptions } from '../../../../../packem_shared/types-GPTFx90c.cjs';
+import '@rollup/plugin-alias';
+import '@rollup/plugin-commonjs';
+import '@rollup/plugin-json';
+import '@rollup/plugin-node-resolve';
+import '@rollup/plugin-replace';
+import '@rollup/plugin-wasm';
+import '@rollup/pluginutils';
+import '@visulima/package';
+import '@visulima/pail';
+import '@visulima/tsconfig';
+import 'hookable';
+import 'jiti';
+import 'rollup';
+import 'rollup-plugin-dts';
+import 'rollup-plugin-polyfill-node';
+import 'rollup-plugin-visualizer';
+import 'typedoc';
+import 'cssnano';
+import 'lightningcss';
+import 'postcss';
+import 'postcss-load-config';
+import 'node-sass';
+import 'sass';
+import 'sass-embedded';
+import '../../../../../packem_shared/types-BLR6WWv2.cjs';
+import 'esbuild';
+import '../../../../../packem_shared/types-DvWhOdt5.cjs';
+import 'sucrase';
+import '../../../../../packem_shared/types-CzGE8V_d.cjs';
+import 'stylus';
+import 'source-map-js';
+
+declare const loader: Loader<LESSLoaderOptions>;
+
+export = loader;

package/dist/rollup/plugins/css/loaders/less/index.d.mts

@@ -0,0 +1,36 @@
+import { L as Loader, i as LESSLoaderOptions } from '../../../../../packem_shared/types-CwzNHNx0.mjs';
+import '@rollup/plugin-alias';
+import '@rollup/plugin-commonjs';
+import '@rollup/plugin-json';
+import '@rollup/plugin-node-resolve';
+import '@rollup/plugin-replace';
+import '@rollup/plugin-wasm';
+import '@rollup/pluginutils';
+import '@visulima/package';
+import '@visulima/pail';
+import '@visulima/tsconfig';
+import 'hookable';
+import 'jiti';
+import 'rollup';
+import 'rollup-plugin-dts';
+import 'rollup-plugin-polyfill-node';
+import 'rollup-plugin-visualizer';
+import 'typedoc';
+import 'cssnano';
+import 'lightningcss';
+import 'postcss';
+import 'postcss-load-config';
+import 'node-sass';
+import 'sass';
+import 'sass-embedded';
+import '../../../../../packem_shared/types-BLR6WWv2.mjs';
+import 'esbuild';
+import '../../../../../packem_shared/types-DvWhOdt5.mjs';
+import 'sucrase';
+import '../../../../../packem_shared/types-CzGE8V_d.mjs';
+import 'stylus';
+import 'source-map-js';
+
+declare const loader: Loader<LESSLoaderOptions>;
+
+export { loader as default };

package/dist/rollup/plugins/css/loaders/less/index.d.ts

@@ -0,0 +1,36 @@
+import { L as Loader, i as LESSLoaderOptions } from '../../../../../packem_shared/types-D8jzF-eM.js';
+import '@rollup/plugin-alias';
+import '@rollup/plugin-commonjs';
+import '@rollup/plugin-json';
+import '@rollup/plugin-node-resolve';
+import '@rollup/plugin-replace';
+import '@rollup/plugin-wasm';
+import '@rollup/pluginutils';
+import '@visulima/package';
+import '@visulima/pail';
+import '@visulima/tsconfig';
+import 'hookable';
+import 'jiti';
+import 'rollup';
+import 'rollup-plugin-dts';
+import 'rollup-plugin-polyfill-node';
+import 'rollup-plugin-visualizer';
+import 'typedoc';
+import 'cssnano';
+import 'lightningcss';
+import 'postcss';
+import 'postcss-load-config';
+import 'node-sass';
+import 'sass';
+import 'sass-embedded';
+import '../../../../../packem_shared/types-BLR6WWv2.js';
+import 'esbuild';
+import '../../../../../packem_shared/types-DvWhOdt5.js';
+import 'sucrase';
+import '../../../../../packem_shared/types-CzGE8V_d.js';
+import 'stylus';
+import 'source-map-js';
+
+declare const loader: Loader<LESSLoaderOptions>;
+
+export = loader;

package/dist/rollup/plugins/css/loaders/less/index.mjs

@@ -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{r as y}from"../../../../../packem_shared/resolve-aYsRgS8e.mjs";import{n as F,g as v}from"../../../../../packem_shared/url-I6Jx3crl.mjs";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,i,t){const a=F(g(r,e)),o=v(a),n={baseDirs:[],caller:"Less importer",extensions:M};Array.isArray(t.paths)&&n.baseDirs.push(...t.paths),n.baseDirs.push(i);const p=y([o,a],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 i=f.render,t=await i(s,{...this.options,filename:this.id,plugins:r,sourceMap:{outputSourceFiles:!0,sourceMapBasepath:u(this.id)}}),a=t.imports;for(const o of a)this.deps.add(d(o));return{code:t.css,map:t.map??e}},test:/\.less$/i};export{U as default};

package/dist/rollup/plugins/css/loaders/lightningcss.cjs

@@ -0,0 +1,3 @@
+"use strict";const t=require("lightningcss"),e=require("../../../../packem_shared/ensure-auto-modules-DBW-5Idh.cjs"),a={name:"lightningCSS",async process({code:i,map:n}){let o=!1;typeof this.options.modules=="boolean"?o=this.options.modules:typeof this.options.modules=="object"&&(o=e.n(this.options.modules.include,this.id)),this.autoModules&&this.options.modules===void 0&&(o=e.n(this.autoModules,this.id));const s=t.transform({...this.options,code:Buffer.from(i),cssModules:this.options.modules??o,filename:this.id,inputSourceMap:n,minify:!1,sourceMap:!this.sourceMap,targets:t.browserslistToTargets(this.browserTargets)});return s.warnings.length>0&&this.warn(`warnings when transforming css:
+`+s.warnings.map(r=>r.message).join(`
+`)),{code:s.code.toString(),map:s.map?JSON.parse(Buffer.from(s.map).toString()):void 0}},test:/\.css$/i};module.exports=a;

package/dist/rollup/plugins/css/loaders/lightningcss.d.cts

@@ -0,0 +1,36 @@
+import { L as Loader, l as LightningCSSOptions } from '../../../../packem_shared/types-GPTFx90c.cjs';
+import '@rollup/plugin-alias';
+import '@rollup/plugin-commonjs';
+import '@rollup/plugin-json';
+import '@rollup/plugin-node-resolve';
+import '@rollup/plugin-replace';
+import '@rollup/plugin-wasm';
+import '@rollup/pluginutils';
+import '@visulima/package';
+import '@visulima/pail';
+import '@visulima/tsconfig';
+import 'hookable';
+import 'jiti';
+import 'rollup';
+import 'rollup-plugin-dts';
+import 'rollup-plugin-polyfill-node';
+import 'rollup-plugin-visualizer';
+import 'typedoc';
+import 'cssnano';
+import 'lightningcss';
+import 'postcss';
+import 'postcss-load-config';
+import 'node-sass';
+import 'sass';
+import 'sass-embedded';
+import '../../../../packem_shared/types-BLR6WWv2.cjs';
+import 'esbuild';
+import '../../../../packem_shared/types-DvWhOdt5.cjs';
+import 'sucrase';
+import '../../../../packem_shared/types-CzGE8V_d.cjs';
+import 'stylus';
+import 'source-map-js';
+
+declare const lightningCSSLoader: Loader<LightningCSSOptions>;
+
+export = lightningCSSLoader;

package/dist/rollup/plugins/css/loaders/lightningcss.d.mts

@@ -0,0 +1,36 @@
+import { L as Loader, l as LightningCSSOptions } from '../../../../packem_shared/types-CwzNHNx0.mjs';
+import '@rollup/plugin-alias';
+import '@rollup/plugin-commonjs';
+import '@rollup/plugin-json';
+import '@rollup/plugin-node-resolve';
+import '@rollup/plugin-replace';
+import '@rollup/plugin-wasm';
+import '@rollup/pluginutils';
+import '@visulima/package';
+import '@visulima/pail';
+import '@visulima/tsconfig';
+import 'hookable';
+import 'jiti';
+import 'rollup';
+import 'rollup-plugin-dts';
+import 'rollup-plugin-polyfill-node';
+import 'rollup-plugin-visualizer';
+import 'typedoc';
+import 'cssnano';
+import 'lightningcss';
+import 'postcss';
+import 'postcss-load-config';
+import 'node-sass';
+import 'sass';
+import 'sass-embedded';
+import '../../../../packem_shared/types-BLR6WWv2.mjs';
+import 'esbuild';
+import '../../../../packem_shared/types-DvWhOdt5.mjs';
+import 'sucrase';
+import '../../../../packem_shared/types-CzGE8V_d.mjs';
+import 'stylus';
+import 'source-map-js';
+
+declare const lightningCSSLoader: Loader<LightningCSSOptions>;
+
+export { lightningCSSLoader as default };