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

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,16 +1,31 @@
-import { Options } from 'cssnano';
-import { M as Minifier } from '../packem_shared/types-B7InbTq8.js';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { 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 as default };
+export default cssnanoMinifier;

package/dist/minifiers/lightningcss.d.ts

@@ -1,16 +1,30 @@
-import { M as Minifier, a as InternalStyleOptions } from '../packem_shared/types-B7InbTq8.js';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import 'postcss-load-config';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import '@visulima/packem-share/utils';
-import 'rollup';
-import 'source-map-js';
-
+import type { InternalStyleOptions } from "../types.d.ts";
+import type { 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 as default };
+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/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;
+}

package/dist/utils/array-fmt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Formats an array of strings into a human-readable list format.
+ *
+ * Converts an array into a grammatically correct string with proper conjunctions:
+ * - Single item: "`item`"
+ * - Two items: "`item1` or `item2`"
+ * - Multiple items: "`item1`, `item2`, or `item3`"
+ * @param array Array of strings to format
+ * @returns Formatted string with proper conjunctions and backticks
+ * @example
+ * ```typescript
+ * arrayFmt(['inject']) // "`inject`"
+ * arrayFmt(['inject', 'extract']) // "`inject` or `extract`"
+ * arrayFmt(['inject', 'extract', 'emit']) // "`inject`, `extract`, or `emit`"
+ * ```
+ */
+declare const arrayFmt: (array: string[]) => string;
+export default arrayFmt;

package/dist/utils/concat.d.ts

@@ -0,0 +1,34 @@
+import { SourceMapGenerator } from "source-map-js";
+import type { Extracted } from "../loaders/types.d.ts";
+interface Concatenated {
+    css: string;
+    map: SourceMapGenerator;
+}
+/**
+ * Concatenates multiple CSS data objects into a single unified object with source map support.
+ *
+ * This utility function merges CSS content from multiple sources while
+ * properly handling source maps and metadata. It's used during the build
+ * process to combine CSS from different modules or chunks while preserving
+ * accurate source mapping information for debugging.
+ *
+ * The function:
+ * - Concatenates CSS content with newline separators
+ * - Merges source maps from all inputs
+ * - Adjusts line/column mappings for the combined output
+ * - Preserves source content for debugging
+ * @param extracted Array of extracted CSS data objects to concatenate
+ * @returns Promise resolving to concatenated CSS with merged source maps
+ * @example
+ * ```typescript
+ * const extracted = [
+ *   { css: '.header {}', map: headerSourceMap },
+ *   { css: '.footer {}', map: footerSourceMap }
+ * ];
+ *
+ * const result = await concat(extracted);
+ * // Result: Combined CSS with properly merged source maps
+ * ```
+ */
+declare const concat: (extracted: Extracted[]) => Promise<Concatenated>;
+export default concat;

package/dist/utils/generate-js-exports.d.ts

@@ -0,0 +1,78 @@
+import type { InjectOptions } from "../types.d.ts";
+export interface JsExportOptions {
+    /** CSS content to export */
+    css: string;
+    /** Current working directory for relative path calculations */
+    cwd?: string;
+    /** Whether to generate TypeScript declarations */
+    dts?: boolean;
+    /** Whether to emit CSS instead of JavaScript */
+    emit?: boolean;
+    /** Whether to extract CSS to separate files */
+    extract?: boolean | string;
+    /** ICSS dependencies for CSS modules */
+    icssDependencies?: string[];
+    /** File ID for safe identifier generation */
+    id: string;
+    /** CSS injection configuration */
+    inject?: InjectOptions | boolean | ((varname: string, id: string, output: string[]) => string);
+    /** Whether to inline CSS as strings */
+    inline?: boolean;
+    /** Logger for warnings */
+    logger?: {
+        warn: (log: {
+            message: string;
+            plugin?: string;
+        }) => void;
+    };
+    /** Source map for the CSS */
+    map?: string;
+    /** CSS modules exports mapping class names to hashed names */
+    modulesExports: Record<string, string>;
+    /** Named exports configuration */
+    namedExports?: boolean | ((name: string) => string);
+    /** Whether CSS modules are supported */
+    supportModules: boolean;
+}
+export interface JsExportResult {
+    /** Generated JavaScript code */
+    code: string;
+    /** Extracted CSS data for file extraction */
+    extracted?: {
+        css: string;
+        id: string;
+        map?: string;
+    };
+    /** Source map */
+    map?: string;
+    /** Metadata including types and module contents */
+    meta?: {
+        icssDependencies?: string[];
+        moduleContents?: string;
+        types?: string;
+    };
+    /** Module side effects configuration */
+    moduleSideEffects: boolean | "no-treeshake";
+    /** Generated TypeScript declarations */
+    types?: string;
+}
+/**
+ * Generates JavaScript exports for CSS content with support for CSS modules and injection
+ * @param options Configuration options for export generation
+ * @param options.css CSS content to export
+ * @param options.cwd Current working directory for relative path calculations
+ * @param options.dts Whether to generate TypeScript declarations
+ * @param options.emit Whether to emit CSS instead of JavaScript
+ * @param options.extract Whether to extract CSS to separate files
+ * @param options.icssDependencies ICSS dependencies for CSS modules
+ * @param options.id File ID for safe identifier generation
+ * @param options.inject CSS injection configuration
+ * @param options.inline Whether to inline CSS as strings
+ * @param options.logger Logger for warnings
+ * @param options.map Source map for the CSS
+ * @param options.modulesExports CSS modules exports mapping class names to hashed names
+ * @param options.namedExports Named exports configuration
+ * @param options.supportModules Whether CSS modules are supported
+ * @returns Generated JavaScript code and TypeScript declarations
+ */
+export declare const generateJsExports: ({ css, cwd, dts, emit, extract, icssDependencies, id, inject, inline, logger, map, modulesExports, namedExports, supportModules, }: JsExportOptions) => JsExportResult;

package/dist/utils/index.d.ts

@@ -1,72 +1,9 @@
-import { SourceMapGenerator, RawSourceMap, SourceMapConsumer } from 'source-map-js';
-import { k as Extracted, b as PostCSSOptions, S as StyleOptions, a as InternalStyleOptions, l as LoaderContext } from '../packem_shared/types-B7InbTq8.js';
-import { RollupLogger } from '@visulima/packem-share/utils';
-import { Result } from 'postcss-load-config';
-import { NapiResolveOptions } from 'oxc-resolver';
-import 'cssnano';
-import 'lightningcss';
-import 'postcss';
-import '@visulima/packem-share/types';
-import 'sass';
-import 'sass-embedded';
-import 'stylus';
-import 'rollup';
-
-declare const arrayFmt: (array: string[]) => string;
-
-interface Concatenated {
-    css: string;
-    map: SourceMapGenerator;
-}
-declare const concat: (extracted: Extracted[]) => Promise<Concatenated>;
-
-declare const loadModule: (moduleId: string, cwd: string, logger: RollupLogger) => Promise<any>;
-
-interface Mode {
-    emit: InternalStyleOptions["emit"];
-    extract: InternalStyleOptions["extract"];
-    inject: InternalStyleOptions["inject"];
-    inline: InternalStyleOptions["inline"];
-}
-type PCSSOption = "parser" | "plugin" | "stringifier" | "syntax";
-declare const inferModeOption: (mode: StyleOptions["mode"]) => Mode;
-declare const inferOption: <T, TDefine extends T | boolean | undefined>(option: T | boolean | undefined, defaultValue: TDefine) => OptionType<T, TDefine>;
-declare const inferSourceMapOption: (sourceMap: StyleOptions["sourceMap"]) => LoaderContext["sourceMap"];
-declare const inferHandlerOption: <T extends {
-    alias?: Record<string, string>;
-}>(option: T | boolean | undefined, alias: T["alias"]) => T | false;
-declare const ensurePCSSOption: <T>(option: T | string, type: PCSSOption, cwd: string, logger: RollupLogger) => Promise<T>;
-declare const ensurePCSSPlugins: (plugins: PostCSSOptions["plugins"], cwd: string, logger: RollupLogger) => Promise<Result["plugins"]>;
-type OptionType<T, TDefine extends T | boolean | undefined> = T | TDefine | false;
-
-declare const resolve: (ids: string[], userOptions: ResolveOptions) => string;
-interface ResolveOptions extends NapiResolveOptions {
-    baseDirs?: string[];
-    caller?: string;
-}
-
-declare const safeId: (id: string, ...salt: string[]) => string;
-
-declare class MapModifier {
-    private readonly map?;
-    constructor(map?: RawSourceMap | string);
-    modify(f: (m: RawSourceMap) => void): this;
-    modifySources(op: (source: string) => string): this;
-    resolve(directory?: string): this;
-    relative(directory?: string): this;
-    toObject(): RawSourceMap | undefined;
-    toString(): string | undefined;
-    toConsumer(): SourceMapConsumer | undefined;
-    toCommentData(): string;
-    toCommentFile(fileName: string): string;
-}
-declare const getMap: (code: string, id?: string) => Promise<string | undefined>;
-declare const stripMap: (code: string) => string;
-declare const mm: (map?: RawSourceMap | string) => MapModifier;
-
-declare const hasModuleSpecifier: (url: string) => boolean;
-declare const getUrlOfPartial: (url: string) => string;
-declare const normalizeUrl: (url: string) => string;
-
-export { arrayFmt, concat, ensurePCSSOption, ensurePCSSPlugins, getMap, getUrlOfPartial, hasModuleSpecifier, inferHandlerOption, inferModeOption, inferOption, inferSourceMapOption, loadModule, mm, normalizeUrl, resolve, safeId, stripMap };
-export type { ResolveOptions };
+export { default as arrayFmt } from "./array-fmt.d.ts";
+export { default as concat } from "./concat.d.ts";
+export { default as loadModule } from "./load-module.d.ts";
+export { ensurePCSSOption, ensurePCSSPlugins, inferHandlerOption, inferModeOption, inferOption, inferSourceMapOption } from "./options.d.ts";
+export type { ResolveOptions } from "./resolve.d.ts";
+export { resolve } from "./resolve.d.ts";
+export { default as safeId } from "./safe-id.d.ts";
+export { getMap, mm, stripMap } from "./sourcemap.d.ts";
+export { getUrlOfPartial, hasModuleSpecifier, normalizeUrl } from "./url.d.ts";

package/dist/utils/load-module.d.ts

@@ -0,0 +1,3 @@
+import type { RollupLogger } from "@visulima/packem-share/utils";
+declare const loadModule: (moduleId: string, cwd: string, logger: RollupLogger) => Promise<any>;
+export default loadModule;