@visulima/packem-rollup 1.0.0-alpha.64 → 1.0.0-alpha.66

package/dist/index.d.ts

@@ -1,25 +1,680 @@
-export { default as cachingPlugin } from "./plugins/cache-plugin.d.ts";
-export { default as chunkSplitter } from "./plugins/chunk-splitter/index.d.ts";
-export { default as browserslistToEsbuild } from "./plugins/esbuild/browserslist-to-esbuild.d.ts";
-export { default as fixDynamicImportExtension } from "./plugins/fix-dynamic-import-extension.d.ts";
-export { default as metafilePlugin } from "./plugins/metafile.d.ts";
-export { pureNewExpressionPlugin } from "./plugins/pure-new-expression-plugin.d.ts";
-export { default as resolveFileUrlPlugin } from "./plugins/resolve-file-url.d.ts";
-export type { ExtendedRollupNodeResolveOptions, PackemRollupOptions, RollupPlugins, TransformerFn, TransformerName, } from "./types.d.ts";
-export { default as createSplitChunks } from "./utils/chunks/create-split-chunks.d.ts";
-export { default as getCustomModuleLayer } from "./utils/chunks/get-custom-module-layer.d.ts";
-export { default as getModuleLayer } from "./utils/chunks/get-module-layer.d.ts";
-export type { Alias, ResolverObject as AliasResolverObject, ResolvedAlias, RollupAliasOptions } from "@rollup/plugin-alias";
-export { default as alias } from "@rollup/plugin-alias";
-export type { RollupCommonJSOptions } from "@rollup/plugin-commonjs";
-export { default as commonjs } from "@rollup/plugin-commonjs";
-export type { RollupDynamicImportVariablesOptions } from "@rollup/plugin-dynamic-import-vars";
-export { default as dynamicImportVars } from "@rollup/plugin-dynamic-import-vars";
-export { default as inject, type RollupInjectOptions } from "@rollup/plugin-inject";
-export { default as nodeResolve, type RollupNodeResolveOptions } from "@rollup/plugin-node-resolve";
-export { default as replace, type RollupReplaceOptions } from "@rollup/plugin-replace";
-export { type RollupWasmOptions, default as wasm } from "@rollup/plugin-wasm";
-export { default as polyfillNode, type NodePolyfillsOptions as RollupNodePolyfillsOptions } from "rollup-plugin-polyfill-node";
-export { PluginPure as purePlugin, type PureAnnotationsOptions as RollupPureAnnotationsOptions } from "rollup-plugin-pure";
-export type { PluginVisualizerOptions as RollupPluginVisualizerOptions } from "rollup-plugin-visualizer";
-export { default as visualizer } from "rollup-plugin-visualizer";
+export { default as chunkSplitter } from "./plugins/chunk-splitter/index.js";
+import { c as Options$3 } from "./packem_shared/types.d-KBgVO47q.js";
+export { d as browserslistToEsbuild } from "./packem_shared/types.d-KBgVO47q.js";
+import { JSXRemoveAttributesPlugin } from "./plugins/jsx-remove-attributes.js";
+export { jsxRemoveAttributes } from "./plugins/jsx-remove-attributes.js";
+export { type PreserveDirectivesPluginOptions, preserveDirectivesPlugin } from "./plugins/preserve-directives.js";
+export { pureNewExpressionPlugin } from "./plugins/pure-new-expression-plugin.js";
+import { RollupAliasOptions } from '@rollup/plugin-alias';
+export { type Alias, type ResolverObject as AliasResolverObject, type ResolvedAlias, type RollupAliasOptions, default as alias } from '@rollup/plugin-alias';
+import { RollupCommonJSOptions } from '@rollup/plugin-commonjs';
+export { type RollupCommonJSOptions, default as commonjs } from '@rollup/plugin-commonjs';
+import { RollupJsonOptions } from '@rollup/plugin-json';
+import { RollupNodeResolveOptions } from '@rollup/plugin-node-resolve';
+export { type RollupNodeResolveOptions, default as nodeResolve } from '@rollup/plugin-node-resolve';
+import { RollupReplaceOptions } from '@rollup/plugin-replace';
+export { type RollupReplaceOptions, default as replace } from '@rollup/plugin-replace';
+import { RollupWasmOptions } from '@rollup/plugin-wasm';
+export { type RollupWasmOptions, default as wasm } from '@rollup/plugin-wasm';
+import { FilterPattern } from '@rollup/pluginutils';
+import { TransformOptions } from '@babel/core';
+import { ResolvedId, OutputOptions, Plugin, RollupOptions } from 'rollup';
+import { NapiResolveOptions } from 'oxc-resolver';
+import { TransformOptions as TransformOptions$1, JsxOptions } from 'oxc-transform';
+import '@visulima/package';
+import '@visulima/packem-share/types';
+import { SourceMapOptions } from 'magic-string';
+import 'clean-css';
+import { MinifierOptions } from 'html-minifier-next';
+import { Options as Options$2 } from '@visulima/rollup-plugin-dts';
+import { NodePolyfillsOptions } from 'rollup-plugin-polyfill-node';
+export { type NodePolyfillsOptions as RollupNodePolyfillsOptions, default as polyfillNode } from 'rollup-plugin-polyfill-node';
+import { PureAnnotationsOptions } from 'rollup-plugin-pure';
+export { type PureAnnotationsOptions as RollupPureAnnotationsOptions, PluginPure as purePlugin } from 'rollup-plugin-pure';
+import { PluginVisualizerOptions } from 'rollup-plugin-visualizer';
+export { type PluginVisualizerOptions as RollupPluginVisualizerOptions, default as visualizer } from 'rollup-plugin-visualizer';
+import { CJSInteropOptions } from "./plugins/cjs-interop.js";
+import { SucrasePluginConfig } from "./plugins/sucrase/index.js";
+import { S as SwcPluginConfig } from "./packem_shared/types.d-Dmpk2asd.js";
+export { type RollupDynamicImportVariablesOptions, default as dynamicImportVars } from '@rollup/plugin-dynamic-import-vars';
+export { type RollupInjectOptions, default as inject } from '@rollup/plugin-inject';
+export { importTrace, patchErrorWithTrace } from 'rollup-plugin-import-trace';
+import '@visulima/packem-share/utils';
+import "./packem_shared/types.d-DrgzeMBs.d-CG9J1x6q.js";
+import '@swc/types';
+interface BabelPluginConfig extends Omit<TransformOptions, "filename" | "sourceFileName" | "exclude" | "include"> {
+  exclude?: FilterPattern;
+  filename?: string;
+  include?: FilterPattern;
+  sourceFileName?: string;
+}
+type OXCTransformPluginConfig = Omit<TransformOptions$1, "cwd" | "sourcemap" | "target" | "typescript"> & {
+  exclude?: FilterPattern;
+  include?: FilterPattern; /** Configure how TSX and JSX are transformed. */
+  jsx?: Omit<JsxOptions, "refresh"> | "preserve";
+};
+type OXCResolveOptions = Omit<NapiResolveOptions, "tsconfig"> & {
+  ignoreSideEffectsForRoot?: boolean;
+};
+type SingleTargetDesc = {
+  dest?: string;
+  exclude?: string[] | string;
+  src: string[] | string;
+};
+type MultipleTargetsDesc = SingleTargetDesc | SingleTargetDesc[] | string[] | string;
+type CopyPluginOptions = {
+  /**
+  * Copy items once. Useful in watch mode.
+  * @default false
+  */
+  copyOnce?: boolean;
+  exactFileNames?: boolean;
+  /**
+  * Remove the directory structure of copied files.
+  * @default true
+  */
+  flatten?: boolean;
+  targets: MultipleTargetsDesc;
+};
+type DataUriPluginOptions = {
+  exclude?: FilterPattern;
+  include?: FilterPattern; /** Encode spaces for use in srcset attribute */
+  srcset?: boolean;
+};
+/**
+* Data URI plugin that converts files to data URIs for inline embedding.
+*
+* Supported query parameters:
+*
+* - `?data-uri` - Basic data URI conversion.
+* - `?data-uri and encoding=css` - Use CSS-optimized SVG encoding.
+* - `?data-uri and encoding=tiny` - Use tiny SVG encoding (default).
+* - `?data-uri and srcset` - Encode spaces as %20 for srcset compatibility.
+*
+* Examples:
+*
+* - `./icon.svg?data-uri` - Tiny SVG encoding.
+* - `./icon.svg?data-uri and encoding=css` - CSS-optimized SVG encoding.
+* - `./icon.svg?data-uri and srcset` - Tiny SVG with srcset compatibility.
+* - `./icon.svg?data-uri and encoding=css and srcset` - CSS encoding with srcset compatibility.
+*/
+interface DebarrelPluginOptions {
+  include?: FilterPattern;
+  possibleBarrelFiles?: (RegExp | string)[];
+}
+interface EsmShimCjsSyntaxOptions {
+  exclude?: FilterPattern;
+  include?: FilterPattern;
+}
+type MaybeFalsy<T> = T | false | null | undefined;
+/**
+* User-facing configuration for externals classification, mirrored at
+* `packem.config.ts` → `rollup.resolveExternals`.
+*/
+type ResolveExternalsPluginOptions = {
+  /**
+  * Mark node built-in modules like `path`, `fs`... as external.
+  *
+  * Set to `false` to use shims/polyfills instead.
+  * @default true
+  */
+  builtins?: boolean;
+  /**
+  * `node:` prefix handling for imports of Node builtins:
+  * - `'add'`    turns `'path'` into `'node:path'`
+  * - `'strip'`  turns `'node:path'` into `'path'`
+  * - `'ignore'` leaves names as written
+  * @default "add"
+  */
+  builtinsPrefix?: "add" | "ignore" | "strip";
+  /**
+  * Mark `dependencies` as external.
+  * @default true
+  */
+  deps?: boolean;
+  /**
+  * Mark `devDependencies` as external.
+  * @default false
+  */
+  devDeps?: boolean;
+  /**
+  * Patterns whose matching specifiers are forced to be bundled,
+  * overriding all other rules (deps/peer/built-ins/etc.).
+  *
+  * Strings are matched as exact specifiers; RegExp values are tested
+  * against the import id. Falsy entries are ignored for convenient
+  * conditional configuration.
+  * @default [] (no specifier is forcibly bundled)
+  */
+  exclude?: MaybeFalsy<RegExp | string>[];
+  /**
+  * Mark `optionalDependencies` as external.
+  * @default true
+  */
+  optDeps?: boolean;
+  /**
+  * Mark `peerDependencies` as external.
+  * @default true
+  */
+  peerDeps?: boolean;
+};
+/**
+* Minimal slice of build options consumed by `externalsPlugin`.
+*
+* The plugin lives in `@visulima/packem-rollup` so it can be reused outside
+* of packem core, so it's parameterized over this shape rather than
+* packem's `InternalBuildOptions`. Any options object that satisfies this
+* structural type is accepted.
+*/
+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;
+}
+/**
+* Ported from https://github.com/lit/lit/tree/main/packages/labs/rollup-plugin-minify-html-literals
+*
+* BSD-3-Clause License
+*
+* Copyright (c) 2024 Google LLC
+*/
+interface Template {
+  parts: TemplatePart[];
+  tag?: string;
+}
+interface TemplatePart {
+  end: number;
+  start: number;
+  text: string;
+}
+interface Strategy$1<N = unknown> {
+  getRootNode: (source: string, fileName?: string) => N;
+  getTaggedTemplateTemplate: (node: N) => unknown;
+  getTagText: (node: N) => string;
+  getTemplateParts: (node: N) => TemplatePart[];
+  isTaggedTemplate: (node: N) => boolean;
+  isTemplate: (node: N) => boolean;
+  walkNodes: (parent: N, visit: (child: N) => void) => void;
+}
+interface ParseLiteralsOptions {
+  fileName?: string;
+  strategy?: Partial<Strategy$1>;
+}
+declare const parseLiterals: (source: string, options?: ParseLiteralsOptions) => Template[];
+/**
+* A strategy on how to minify HTML and optionally CSS.
+* @template O minify HTML options
+* @template C minify CSS options
+*/
+interface Strategy<O = unknown, C = unknown> {
+  /**
+  * Combines the parts' HTML text strings together into a single string using
+  * the provided placeholder. The placeholder indicates where a template
+  * expression occurs.
+  * @param parts the parts to combine
+  * @param placeholder the placeholder to use between parts
+  * @returns the combined parts' text strings
+  */
+  combineHTMLStrings: (parts: TemplatePart[], placeholder: string) => string;
+  /**
+  * Retrieve a placeholder for the given array of template parts. The
+  * placeholder returned should be the same if the function is invoked with the
+  * same array of parts.
+  *
+  * The placeholder should be an HTML-compliant string that is not present in
+  * any of the parts' text.
+  * @param parts the parts to get a placeholder for
+  * @returns the placeholder
+  */
+  getPlaceholder: (parts: TemplatePart[]) => string;
+  /**
+  * Minifies the provided CSS string.
+  * @param css the css to minfiy
+  * @param options css minify options
+  * @returns minified CSS string
+  */
+  minifyCSS?: (css: string, options?: C) => string;
+  /**
+  * Minfies the provided HTML string.
+  * @param html the html to minify
+  * @param options html minify options
+  * @returns minified HTML string
+  */
+  minifyHTML: (html: string, options?: O) => string | Promise<string>;
+  /**
+  * Splits a minfied HTML string back into an array of strings from the
+  * provided placeholder. The returned array of strings should be the same
+  * length as the template parts that were combined to make the HTML string.
+  * @param html the html string to split
+  * @param placeholder the placeholder to split by
+  * @returns an array of html strings
+  */
+  splitHTMLByPlaceholder: (html: string, placeholder: string) => string[];
+}
+/**
+* The default &lt;code>html-minifier&lt;/code> options, optimized for production
+* minification.
+*/
+declare const defaultMinifyOptions: MinifierOptions;
+/**
+* Options for &lt;code>minifyHTMLLiterals()&lt;/code>.
+*/
+type Options$1 = DefaultOptions | CustomOptions;
+/**
+* Options for &lt;code>minifyHTMLLiterals()&lt;/code>, using default html-minifier
+* strategy.
+*/
+interface DefaultOptions extends BaseOptions {
+  /**
+  * &lt;code>html-minifier&lt;/code> options to use. Defaults to
+  * &lt;code>defaultMinifyOptions&lt;/code>, for production-ready minification.
+  */
+  minifyOptions?: Partial<typeof defaultMinifyOptions>;
+}
+/**
+* Options for &lt;code>minifyHTMLLiterals()&lt;/code>, using a custom strategy.
+*/
+interface CustomOptions<S extends Strategy<any, any> = Strategy<any, any>> extends BaseOptions {
+  /**
+  * HTML minification options.
+  */
+  minifyOptions?: S extends Strategy<infer O> ? Partial<O> : never;
+  /**
+  * Override the default strategy for how to minify HTML. The default is to
+  * use &lt;code>html-minifier&lt;/code>.
+  */
+  strategy: S;
+}
+/**
+* Options for &lt;code>minifyHTMLLiterals()&lt;/code>.
+*/
+interface BaseOptions {
+  /**
+  * The name of the file. This is used to determine how to parse the source
+  * code and for source map filenames. It may be a base name, relative, or
+  * absolute path.
+  */
+  fileName?: string;
+  /**
+  * Override how source maps are generated. Set to false to disable source map
+  * generation.
+  * @param ms the MagicString instance with code modifications
+  * @param fileName the name or path of the file
+  * @returns a v3 SourceMap or undefined
+  */
+  generateSourceMap?: ((ms: MagicStringLike, fileName: string) => SourceMap | undefined) | false;
+  /**
+  * The MagicString-like constructor to use. MagicString is used to replace
+  * strings and generate source maps.
+  *
+  * Override if you want to set your own version of MagicString or change how
+  * strings are overridden. Use &lt;code>generateSourceMap&lt;/code> if you want to
+  * change how source maps are created.
+  */
+  MagicString?: new (source: string) => MagicStringLike;
+  /**
+  * Override how template literals are parsed from a source string.
+  */
+  parseLiterals?: typeof parseLiterals;
+  /**
+  * Options for &lt;code>parseLiterals()&lt;/code>.
+  */
+  parseLiteralsOptions?: Partial<ParseLiteralsOptions>;
+  /**
+  * Determines whether or not a template should be minified. The default is to
+  * minify all tagged template whose tag name contains "html" (case
+  * insensitive).
+  * @param template the template to check
+  * @returns true if the template should be minified
+  */
+  shouldMinify?: (template: Template) => boolean;
+  /**
+  * Determines whether or not a CSS template should be minified. The default is
+  * to minify all tagged template whose tag name contains "css" (case
+  * insensitive).
+  * @param template the template to check
+  * @returns true if the template should be minified
+  */
+  shouldMinifyCSS?: (template: Template) => boolean;
+  /**
+  * Override custom validation or set to false to disable validation. This is
+  * only useful when implementing your own strategy that may return
+  * unexpected results.
+  */
+  validate?: Validation | false;
+}
+/**
+* A MagicString-like instance. &lt;code>minify-html-literals&lt;/code> only uses a
+* subset of the MagicString API to overwrite the source code and generate
+* source maps.
+*/
+interface MagicStringLike {
+  generateMap: (options?: Partial<SourceMapOptions>) => SourceMap;
+  overwrite: (start: number, end: number, content: string) => unknown;
+  toString: () => string;
+}
+/**
+* A v3 SourceMap.
+*
+* &lt;code>magic-string> incorrectly declares the SourceMap type with a version
+* string instead of a number, so &lt;code>minify-html-literals&lt;/code> declares
+* its own type.
+*/
+interface SourceMap {
+  file?: string;
+  mappings: string;
+  names: string[];
+  sources: string[];
+  sourcesContent?: string[];
+  toString: () => string;
+  toUrl: () => string;
+  version: number;
+}
+/**
+* Validation that is executed when minifying HTML to ensure there are no
+* unexpected errors. This is to alleviate hard-to-troubleshoot errors such as
+* undefined errors.
+*/
+interface Validation {
+  /**
+  * Throws an error if &lt;code>strategy.splitHTMLByPlaceholder()&lt;/code> does not
+  * return an HTML part string for each template part.
+  * @param parts the template parts that generated the strings
+  * @param htmlParts the split HTML strings
+  */
+  ensureHTMLPartsValid: (parts: TemplatePart[], htmlParts: string[]) => void;
+  /**
+  * Throws an error if &lt;code>strategy.getPlaceholder()&lt;/code> does not return
+  * a valid placeholder string.
+  * @param placeholder the placeholder to check
+  */
+  ensurePlaceholderValid: (placeholder: unknown) => void;
+}
+/**
+* The result of a call to &lt;code>minifyHTMLLiterals()&lt;/code>.
+*/
+interface Result {
+  /**
+  * The minified code.
+  */
+  code: string;
+  /**
+  * Optional v3 SourceMap for the code.
+  */
+  map: SourceMap | undefined;
+}
+/**
+* Minifies all HTML template literals in the provided source string.
+* @param source the source code
+* @param options minification options
+* @returns the minified code, or null if no minification occurred.
+*/
+declare function minifyHTMLLiterals$1(source: string, options?: DefaultOptions): Promise<Result | null | undefined>;
+/**
+* Minifies all HTML template literals in the provided source string.
+* @param source the source code
+* @param options minification options
+* @returns the minified code, or null if no minification occurred.
+*/
+declare function minifyHTMLLiterals$1<S extends Strategy>(source: string, options?: CustomOptions<S>): Promise<Result | undefined>;
+/**
+* Plugin options.
+*/
+interface MinifyHTMLLiteralsOptions {
+  /**
+  * Pattern or array of patterns of files not to minify.
+  */
+  exclude?: FilterPattern;
+  /**
+  * If true, any errors while parsing or minifying will abort the bundle
+  * process. Defaults to false, which will only show a warning.
+  */
+  failOnError?: boolean;
+  /**
+  * Pattern or array of patterns of files to minify.
+  */
+  include?: FilterPattern;
+  /**
+  * Override minify-html-literals function.
+  */
+  minifyHTMLLiterals?: typeof minifyHTMLLiterals$1;
+  /**
+  * Minify options, see
+  * https://www.npmjs.com/package/minify-html-literals#options.
+  */
+  options?: Partial<Options$1>;
+}
+interface NativeModulesOptions {
+  /**
+  * Custom subdirectory name for native modules within the output directory
+  * @default 'natives'
+  */
+  nativesDirectory?: string;
+}
+/**
+* Handles native Node.js addons (.node files)
+* - Stage 1 (resolve/load): Identifies .node files and generates runtime code.
+* - Stage 2 (generateBundle): Copies the identified .node files to the output dir.
+*/
+interface RawLoaderOptions {
+  exclude?: FilterPattern;
+  include?: FilterPattern;
+}
+type Awaitable<T> = T | Promise<T>;
+/**
+* @returns A boolean or a promise that resolves to a boolean,
+* or `undefined` to let the plugin decide automatically.
+*/
+type TransformFunction = (id: string, importer: string, rollupResolve: (id: string, importer?: string) => Promise<ResolvedId | null>) => Awaitable<boolean | undefined | void>;
+interface Options {
+  /**
+  * Whether to transform Node.js built-in modules (e.g., `fs`, `path`)
+  * to `process.getBuiltinModule()` calls when supported, which has the best performance.
+  * Falls back to `createRequire()` for older Node.js versions, Bun, and Deno.
+  *
+  * Note: `process.getBuiltinModule` is available since Node.js 20.16.0 and 22.3.0.
+  * For older versions, the plugin uses `createRequire()` as fallback.
+  */
+  builtinNodeModules?: boolean;
+  cwd?: string;
+  exclude?: FilterPattern;
+  include?: FilterPattern;
+  order?: "pre" | "post";
+  /**
+  * A function to determine whether a module should be transformed.
+  * Return `true` to force transformation, `false` to skip transformation,
+  * or `undefined` to let the plugin decide automatically.
+  */
+  shouldTransform?: string[] | TransformFunction;
+}
+type ShebangOptions = {
+  replace: boolean;
+  shebang: string;
+};
+interface SourcemapsPluginOptions {
+  exclude?: FilterPattern;
+  include?: FilterPattern;
+}
+interface UrlOptions {
+  /**
+  * The destination dir to copy assets, usually used to rebase the assets according to HTML files.
+  * @type {string}
+  */
+  destDir?: string;
+  /**
+  * If false, will prevent files being emitted by this plugin. This is useful for when you are using Rollup to emit both a client-side and server-side bundle.
+  * @type {boolean}
+  * @default true
+  */
+  emitFiles: boolean;
+  /**
+  * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+  * should _ignore_.
+  *
+  * By default, no files are ignored.
+  * @type {FilterPattern}
+  */
+  exclude?: FilterPattern;
+  /**
+  * If emitFiles is true, this option can be used to rename the emitted files. It accepts the following string replacements:
+  * [hash] - The hash value of the file's contents
+  * [name] - The name of the imported file (without its file extension)
+  * [extname] - The extension of the imported file (including the leading .)
+  * [dirname] - The parent directory name of the imported file (including trailing /)
+  * @type {string}
+  * @default [hash][extname]
+  */
+  fileName: string;
+  /**
+  * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+  * should operate on.
+  * By default, the png,jpg,jpeg,gif,svg,webp files are targeted.
+  * @type {FilterPattern}
+  */
+  include?: FilterPattern;
+  /**
+  * The file size limit for inline files.
+  * If a file exceeds this limit, it will be copied to the destination folder and the hashed filename will be provided instead.
+  * If limit is set to 0 all files will be copied.
+  * @type {number}
+  * @default 14336 (14kb)
+  */
+  limit: number;
+  /**
+  * A string which will be added in front of filenames when they are not inlined but are copied.
+  * @type {string}
+  */
+  publicPath?: string;
+  /**
+  * When using the [dirname] replacement in fileName, use this directory as the source directory from which to create the file path rather than the parent directory of the imported file. For example:
+  * @example
+  * ```js
+  *    src/path/to/file.js
+  *
+  *    import png from './image.png';
+  *    rollup.config.js
+  *
+  *    url({
+  *      fileName: '[dirname][hash][extname]',
+  *      sourceDir: path.join(__dirname, 'src')
+  *    });
+  *
+  *    Emitted File: path/to/image.png
+  * ```
+  */
+  sourceDir?: string;
+}
+type PatchTypesOptions = {
+  identifierReplacements?: Record<string, Record<string, string>>;
+};
+/**
+* Patches the bundled types output before passing to the dts plugin.
+*
+* 1. Validate unallowed dependency imports.
+* 2. Replace confusing type names.
+* 3. Strip leftover internal types.
+* 4. Clean unnecessary comments.
+*/
+type TsconfigPathsPluginOptions = {
+  resolveAbsolutePath?: boolean;
+};
+/**
+* Rollup plugin that resolves module ids using `tsconfig.json`/`jsconfig.json` "paths".
+*
+* Handles tsconfig.json or jsconfig.json "paths" option for rollup, largely based
+* on how the TypeScript compiler handles it.
+* @see https://github.com/microsoft/TypeScript/blob/1a9c8197fffe3dace5f8dca6633d450a88cba66d/src/compiler/moduleNameResolver.ts#L1362
+*/
+interface RollupDynamicImportVariablesOptions {
+  /**
+  * By default, the plugin will not throw errors when target files are not found.
+  * Setting this option to true will result in errors thrown when encountering files which don't exist.
+  * @default false
+  */
+  errorWhenNoFilesFound?: boolean;
+  /**
+  * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+  * should _ignore_.
+  *
+  * By default, no files are ignored.
+  */
+  exclude?: FilterPattern;
+  /**
+  * A picomatch pattern, or array of patterns, which specifies the files in the build the plugin
+  * should operate on.
+  * By default, all files are targeted.
+  */
+  include?: FilterPattern;
+  /**
+  * By default, the plugin quits the build process when it encounters an error.
+  * If you set this option to true, it will throw a warning instead and leave the code untouched.
+  * @default false
+  */
+  warnOnError?: boolean;
+}
+interface ExtendedRollupNodeResolveOptions extends RollupNodeResolveOptions {
+  /**
+  * Controls how unresolved import warnings from the node-resolve plugin are handled.
+  * - `"error"` (default): Treat unresolved imports as errors, causing the build to fail
+  * - `"warn"`: Treat unresolved imports as warnings, allowing the build to continue
+  * @default "error"
+  */
+  unresolvedImportBehavior?: "error" | "warn";
+}
+interface PackemRollupOptions {
+  alias?: RollupAliasOptions | false;
+  babel?: BabelPluginConfig | false;
+  cjsInterop?: CJSInteropOptions;
+  commonjs?: RollupCommonJSOptions | false;
+  copy?: CopyPluginOptions | false;
+  dataUri?: DataUriPluginOptions | false;
+  debarrel?: DebarrelPluginOptions | false;
+  dts?: Options$2;
+  dynamicVars?: RollupDynamicImportVariablesOptions | false;
+  esbuild?: Options$3 | false;
+  experimental?: {
+    resolve?: OXCResolveOptions | false;
+  };
+  json?: RollupJsonOptions | false;
+  jsxRemoveAttributes?: JSXRemoveAttributesPlugin | false;
+  license?: LicenseOptions | false;
+  metafile?: boolean;
+  minifyHTMLLiterals?: MinifyHTMLLiteralsOptions | false;
+  nativeModules?: NativeModulesOptions | false;
+  output?: OutputOptions;
+  oxc?: Omit<OXCTransformPluginConfig, "cwd" | "sourcemap" | "target"> | false;
+  patchTypes?: PatchTypesOptions | false;
+  plugins?: RollupPlugins;
+  polyfillNode?: NodePolyfillsOptions | false;
+  preserveDirectives?: {
+    directiveRegex?: RegExp;
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+  };
+  preserveDynamicImports?: boolean;
+  pure?: Omit<PureAnnotationsOptions, "sourcemap"> | false;
+  raw?: RawLoaderOptions | false;
+  replace?: Omit<RollupReplaceOptions, "cwd"> | false;
+  requireCJS?: Options | false;
+  resolve?: ExtendedRollupNodeResolveOptions | false;
+  resolveExternals?: ResolveExternalsPluginOptions;
+  shebang?: Partial<ShebangOptions> | false;
+  shim?: EsmShimCjsSyntaxOptions | false;
+  sourcemap?: SourcemapsPluginOptions;
+  sucrase?: SucrasePluginConfig | false;
+  swc?: SwcPluginConfig | false;
+  treeshake?: RollupOptions["treeshake"];
+  tsconfigPaths?: TsconfigPathsPluginOptions | false;
+  url?: UrlOptions | false;
+  visualizer?: PluginVisualizerOptions | false;
+  wasm?: RollupWasmOptions | false;
+  watch?: RollupOptions["watch"];
+}
+type RollupPlugins = {
+  enforce?: "post" | "pre";
+  plugin: Plugin;
+  type?: "build" | "dts";
+}[];
+export { type ExtendedRollupNodeResolveOptions, type JSXRemoveAttributesPlugin, type PackemRollupOptions, type RollupPlugins };