@visulima/packem-rollup 1.0.0-alpha.6 → 1.0.0-alpha.61

package/dist/plugins/minify-html-literals/lib/minify-html-literals.d.ts

@@ -0,0 +1,200 @@
+/**
+ * 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
+ */
+import type { SourceMapOptions } from "magic-string";
+import type { Template, TemplatePart } from "./models.d.ts";
+import type { ParseLiteralsOptions } from "./parse-literals.d.ts";
+import { parseLiterals } from "./parse-literals.d.ts";
+import type { Strategy } from "./strategy.d.ts";
+import { defaultMinifyOptions } from "./strategy.d.ts";
+/**
+ * Options for <code>minifyHTMLLiterals()</code>.
+ */
+export type Options = DefaultOptions | CustomOptions<unknown>;
+/**
+ * Options for &lt;code>minifyHTMLLiterals()&lt;/code>, using default html-minifier
+ * strategy.
+ */
+export 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.
+ */
+export interface CustomOptions<S extends Strategy | unknown> 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>.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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>.
+ */
+export interface Result {
+    /**
+     * The minified code.
+     */
+    code: string;
+    /**
+     * Optional v3 SourceMap for the code.
+     */
+    map: SourceMap | undefined;
+}
+/**
+ * The default method to generate a SourceMap. It will generate the SourceMap
+ * from the provided MagicString instance using "fileName.map" as the file and
+ * "fileName" as the source.
+ * @param ms the MagicString instance with code modifications
+ * @param fileName the name of the source file
+ * @returns a v3 SourceMap
+ */
+export declare const defaultGenerateSourceMap: (ms: MagicStringLike, fileName: string) => SourceMap;
+/**
+ * The default method to determine whether or not to minify a template. It will
+ * return true for all tagged templates whose tag name contains "html" (case
+ * insensitive).
+ * @param template the template to check
+ * @returns true if the template should be minified
+ */
+export declare const defaultShouldMinify: (template: Template) => boolean;
+/**
+ * The default method to determine whether or not to minify a CSS template. It
+ * will return true for all tagged templates whose tag name contains "css" (case
+ * insensitive).
+ * @param template the template to check
+ * @returns true if the template should be minified
+ */
+export declare const defaultShouldMinifyCSS: (template: Template) => boolean;
+export declare const defaultValidation: Validation;
+/**
+ * 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.
+ */
+export declare function minifyHTMLLiterals(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.
+ */
+export declare function minifyHTMLLiterals<S extends Strategy>(source: string, options?: CustomOptions<S>): Promise<Result | undefined>;

package/dist/plugins/minify-html-literals/lib/models.d.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+export interface Template {
+    parts: TemplatePart[];
+    tag?: string;
+}
+export interface TemplatePart {
+    end: number;
+    start: number;
+    text: string;
+}
+export interface Strategy<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;
+}

package/dist/plugins/minify-html-literals/lib/parse-literals.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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
+ */
+import type { Strategy, Template } from "./models.d.ts";
+export interface ParseLiteralsOptions {
+    fileName?: string;
+    strategy?: Partial<Strategy<unknown>>;
+}
+export declare const parseLiterals: (source: string, options?: ParseLiteralsOptions) => Template[];

package/dist/plugins/minify-html-literals/lib/strategy.d.ts

@@ -0,0 +1,69 @@
+import CleanCSS from "clean-css";
+import type { MinifierOptions as HTMLOptions } from "html-minifier-next";
+import type { TemplatePart } from "./models.d.ts";
+/**
+ * A strategy on how to minify HTML and optionally CSS.
+ * @template O minify HTML options
+ * @template C minify CSS options
+ */
+export 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>clean-css&lt;/code> options, optimized for production
+ * minification.
+ */
+export declare const defaultMinifyCSSOptions: CleanCSS.Options;
+/**
+ * The default &lt;code>html-minifier&lt;/code> options, optimized for production
+ * minification.
+ */
+export declare const defaultMinifyOptions: HTMLOptions;
+export declare const adjustMinifyCSSOptions: (options?: CleanCSS.Options) => CleanCSS.Options;
+/**
+ * The default strategy. This uses &lt;code>html-minifier&lt;/code> to minify HTML and
+ * &lt;code>clean-css&lt;/code> to minify CSS.
+ */
+export declare const defaultStrategy: Strategy<HTMLOptions, CleanCSS.Options>;

package/dist/plugins/minify-html-literals/lib/typescript.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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
+ */
+import ts from "typescript";
+import type { TemplatePart } from "./models.d.ts";
+export interface TypescriptStrategy {
+    getHeadTemplatePart: (node: ts.TemplateLiteral | ts.TemplateHead) => TemplatePart;
+    getMiddleTailTemplatePart: (node: ts.TemplateMiddle | ts.TemplateTail) => TemplatePart;
+    getRootNode: (source: string, fileName?: string) => ts.SourceFile;
+    getTaggedTemplateTemplate: (node: ts.TaggedTemplateExpression) => ts.TemplateLiteral;
+    getTagText: (node: ts.TaggedTemplateExpression) => string;
+    getTemplateParts: (node: ts.TemplateLiteral) => TemplatePart[];
+    isTaggedTemplate: (node: ts.Node) => node is ts.TaggedTemplateExpression;
+    isTemplate: (node: ts.Node) => node is ts.TemplateLiteral;
+    walkChildNodes: (node: ts.Node, visit: (node: ts.Node) => void) => void;
+    walkNodes: (root: ts.SourceFile, visit: (node: ts.Node) => void) => void;
+}
+declare const _default: TypescriptStrategy;
+export default _default;

package/dist/plugins/native-modules-plugin.d.ts

@@ -0,0 +1,14 @@
+import type { Plugin } from "rollup";
+export 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.
+ */
+export declare const nativeModulesPlugin: (config?: NativeModulesOptions) => Plugin;

package/dist/plugins/native-modules-plugin.js

@@ -0,0 +1 @@
+var $=Object.defineProperty;var m=(a,i)=>$(a,"name",{value:i,configurable:!0});import{copyFile as w}from"node:fs/promises";import{isAccessible as A,ensureDir as P}from"@visulima/fs";import{resolve as v,dirname as c,basename as f,extname as b,join as g}from"@visulima/path";var x=Object.defineProperty,h=m((a,i)=>x(a,"name",{value:i,configurable:!0}),"f");const d="\0natives:",B=h((a={})=>{const{nativesDirectory:i="natives"}=a,u=new Map;let n;return{buildStart(){u.clear()},generateBundle:h(async r=>{if(u.size===0)return;if(n||(r.dir?n=r.dir:r.file&&(n=c(r.file))),!n)throw new Error("Output directory not detected. Please ensure Rollup output options are configured.");const t=g(n,i);await P(t),await Promise.all(Array.from(u.entries(),([e,o])=>{const s=g(t,o);return w(e,s)}))},"generateBundle"),load(r){if(!r.startsWith(d))return;const t=r.slice(d.length),e=u.get(t);if(e||this.error(`Could not find staged native module for: ${t}`),!n){const o=this;if(o&&o.meta&&o.meta.rollupVersion)return`export default require("./${i}/${e}");`;this.error("Output directory not detected. Please ensure Rollup output options are configured.")}return`export default require("${`./${i}/${e}`.replaceAll("\\","/")}");`},name:"native-modules",options(r){const t=r;if(t.output){const e=Array.isArray(t.output)?t.output[0]:t.output;e.dir?n=e.dir:e.file&&(n=c(e.file))}return r},resolveId:{filter:{id:/\.node$/},async handler(r,t){if(r.startsWith(d))return;const e=t?v(c(t),r):v(r);if(!await A(e)){this.warn(`Native module not found: ${e}`);return}const o=f(e);let s=o,p=1;const y=new Set(Array.from(u.values(),l=>f(l)));for(;y.has(s);){const l=b(o);s=`${f(o,l)}_${p}${l}`,p+=1}return u.set(e,s),d+e}}}},"nativeModulesPlugin");export{B as nativeModulesPlugin};

package/dist/plugins/oxc/index.d.ts

@@ -1,28 +1,3 @@
-import { G as OxcResolveOptions, P as PailServerType, T as TransformerFn, k as IsolatedDeclarationsResult } from '../../packem_shared/types-yL82LLIx.js';
-export { H as InternalOXCTransformPluginConfig, K as OXCTransformPluginConfig } from '../../packem_shared/types-yL82LLIx.js';
-import { Plugin } from 'rollup';
-import { IsolatedDeclarationsOptions } from 'oxc-transform';
-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 'rollup-plugin-dts';
-import 'rollup-plugin-polyfill-node';
-import 'rollup-plugin-pure';
-import 'rollup-plugin-visualizer';
-import 'esbuild';
-import '@visulima/package';
-import '@visulima/packem-share/types';
-import 'oxc-resolver';
-import 'sucrase';
-
-declare const oxcResolvePlugin: (options: OxcResolveOptions, rootDirectory: string, logger: PailServerType, tsconfigPath?: string) => Plugin;
-
-declare const oxcTransformPlugin: TransformerFn;
-
-declare const isolatedDeclarationsOxcTransformer: (id: string, code: string, sourceMap?: boolean, transformOptions?: Omit<IsolatedDeclarationsOptions, "sourcemap">) => IsolatedDeclarationsResult;
-
-export { OxcResolveOptions, isolatedDeclarationsOxcTransformer, oxcResolvePlugin, oxcTransformPlugin };
+export { default as oxcResolvePlugin } from "./oxc-resolve-plugin.d.ts";
+export { default as oxcTransformPlugin } from "./oxc-transformer-plugin.d.ts";
+export type { InternalOXCTransformPluginConfig, OxcResolveOptions, OXCTransformPluginConfig } from "./types.d.ts";

package/dist/plugins/oxc/index.js

@@ -0,0 +1 @@
+import{default as r}from"../../packem_shared/oxcResolvePlugin-SH1JFonc.js";import{default as f}from"../../packem_shared/oxcTransformPlugin-BGmQroQ4.js";export{r as oxcResolvePlugin,f as oxcTransformPlugin};

package/dist/plugins/oxc/oxc-resolve-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "rollup";
+import type { OxcResolveOptions } from "./types.d.ts";
+declare const oxcResolvePlugin: (options: OxcResolveOptions, rootDirectory: string, logger: Console, tsconfigPath?: string) => Plugin;
+export default oxcResolvePlugin;

package/dist/plugins/oxc/oxc-transformer-plugin.d.ts

@@ -0,0 +1,3 @@
+import type { TransformerFn as TransformerFunction } from "../../types.d.ts";
+declare const oxcTransformPlugin: TransformerFunction;
+export default oxcTransformPlugin;

package/dist/plugins/oxc/types.d.ts

@@ -0,0 +1,16 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { NapiResolveOptions } from "oxc-resolver";
+import type { JsxOptions, TransformOptions } from "oxc-transform";
+export type InternalOXCTransformPluginConfig = TransformOptions & {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+};
+export type OXCTransformPluginConfig = Omit<TransformOptions, "cwd" | "sourcemap" | "target" | "typescript"> & {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+    /** Configure how TSX and JSX are transformed. */
+    jsx?: Omit<JsxOptions, "refresh"> | "preserve";
+};
+export type OxcResolveOptions = Omit<NapiResolveOptions, "tsconfig"> & {
+    ignoreSideEffectsForRoot?: boolean;
+};

package/dist/plugins/preserve-directives.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Modified copy of https://github.com/huozhi/rollup-preserve-directives/blob/main/src/index.ts
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2018 these people -> https://github.com/huozhi/rollup-preserve-directives/graphs/contributors
+ */
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin } from "rollup";
+export type PreserveDirectivesPluginOptions = {
+    directiveRegex: RegExp;
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+    logger: Console;
+};
+export declare const preserveDirectivesPlugin: ({ directiveRegex, exclude, include, logger }: PreserveDirectivesPluginOptions) => Plugin;

package/dist/{packem_shared/preserveDirectivesPlugin-B49Cbykd.mjs → plugins/preserve-directives.js}

@@ -1,4 +1,4 @@
-var b=Object.defineProperty;var v=(a,d)=>b(a,"name",{value:d,configurable:!0});import{createFilter as x}from"@rollup/pluginutils";import g from"magic-string";var y=Object.defineProperty,$=v((a,d)=>y(a,"name",{value:d,configurable:!0}),"c");const S=$(({directiveRegex:a,exclude:d=[],include:m=[],logger:p})=>{const u={},f={},h=x(m,d);return{name:"packem:preserve-directives",onLog(i,t){if(t.code==="MODULE_LEVEL_DIRECTIVE"&&i==="warn")return!1},renderChunk:{handler(i,t,{sourcemap:c}){const s=t.moduleIds.map(r=>{if(u[r])return u[r]}).reduce((r,l)=>(l&&l.forEach(o=>{r.add(o)}),r),new Set),n=new g(i);s.size>0&&(p.debug({message:`directives for chunk "${t.fileName}" are preserved.`,prefix:"plugin:preserve-directives"}),n.prepend(`${[...s].map(r=>`'${r}';`).join(`
+var b=Object.defineProperty;var v=(d,o)=>b(d,"name",{value:o,configurable:!0});import{createFilter as x}from"@rollup/pluginutils";import g from"magic-string";var y=Object.defineProperty,$=v((d,o)=>y(d,"name",{value:o,configurable:!0}),"l");const S=$(({directiveRegex:d,exclude:o=[],include:m=[],logger:p})=>{const u={},f={},h=x(m,o);return{name:"packem:preserve-directives",onLog(i,t){if(t.code==="MODULE_LEVEL_DIRECTIVE"&&i==="warn")return!1},renderChunk:{handler(i,t,{sourcemap:c}){const s=t.moduleIds.map(r=>{if(u[r])return u[r]}).reduce((r,l)=>(l&&l.forEach(a=>{r.add(a)}),r),new Set),n=new g(i);s.size>0&&(p.debug({message:`directives for chunk "${t.fileName}" are preserved.`,prefix:"plugin:preserve-directives"}),n.prepend(`${Array.from(s,r=>`'${r}';`).join(`
 `)}
 `));let e;if(t.facadeModuleId&&typeof f[t.facadeModuleId]=="string"&&(e=f[t.facadeModuleId]),e&&(p.debug({message:`shebang for chunk "${t.fileName}" is preserved.`,prefix:"plugin:preserve-directives"}),n.prepend(`${e}
-`)),!(s.size===0&&e===void 0))return{code:n.toString(),map:c?n.generateMap({hires:!0}):void 0}},order:"post"},transform(i,t){if(!h(t))return;let c=!1;const s=new g(i);if(i.startsWith("#")&&i[1]==="!"){let e=0;for(let r=2,l=i.length;r<l;r++){const o=i.codePointAt(r);if(o===10||o===13||o===8232||o===8233){e=r;break}}e&&(f[t]=i.slice(0,e),s.remove(0,e+1),c=!0,p.debug({message:`shebang for module "${t}" is preserved.`,prefix:"plugin:preserve-directives"}))}let n;try{n=this.parse(s.toString(),{allowReturnOutsideFunction:!0})}catch(e){this.warn({code:"PARSE_ERROR",message:`failed to parse "${t}" and extract the directives.`}),p.warn(e);return}if(n.type==="Program"){for(const e of n.body.filter(Boolean)){if(e.type!=="ExpressionStatement")break;let r;"directive"in e?r=e.directive:e.expression.type==="Literal"&&typeof e.expression.value=="string"&&a.test(e.expression.value)&&(r=e.expression.value),r!=="use strict"&&r&&(u[t]||=new Set,u[t].add(r),"start"in e&&typeof e.start=="number"&&"end"in e&&typeof e.end=="number"&&(s.remove(e.start,e.end),c=!0),p.debug({message:`directive "${r}" for module "${t}" is preserved.`,prefix:"plugin:preserve-directives"}))}if(c)return{code:s.toString(),map:s.generateMap({hires:!0}),meta:{preserveDirectives:{directives:[...u[t]??[]],shebang:f[t]??void 0}}}}}}},"preserveDirectives");export{S as default};
+`)),!(s.size===0&&e===void 0))return{code:n.toString(),map:c?n.generateMap({hires:!0}):void 0}},order:"post"},transform(i,t){if(!h(t))return;let c=!1;const s=new g(i);if(i.startsWith("#")&&i[1]==="!"){let e=0;for(let r=2,l=i.length;r<l;r++){const a=i.codePointAt(r);if(a===10||a===13||a===8232||a===8233){e=r;break}}e&&(f[t]=i.slice(0,e),s.remove(0,e+1),c=!0,p.debug({message:`shebang for module "${t}" is preserved.`,prefix:"plugin:preserve-directives"}))}let n;try{n=this.parse(s.toString(),{allowReturnOutsideFunction:!0})}catch(e){this.warn({code:"PARSE_ERROR",message:`failed to parse "${t}" and extract the directives.`}),p.warn(e);return}if(n.type==="Program"){for(const e of n.body.filter(Boolean)){if(e.type!=="ExpressionStatement")break;let r;"directive"in e?r=e.directive:e.expression.type==="Literal"&&typeof e.expression.value=="string"&&d.test(e.expression.value)&&(r=e.expression.value),r!=="use strict"&&r&&(u[t]||=new Set,u[t].add(r),"start"in e&&typeof e.start=="number"&&"end"in e&&typeof e.end=="number"&&(s.remove(e.start,e.end),c=!0),p.debug({message:`directive "${r}" for module "${t}" is preserved.`,prefix:"plugin:preserve-directives"}))}if(c)return{code:s.toString(),map:s.generateMap({hires:!0}),meta:{preserveDirectives:{directives:[...u[t]??[]],shebang:f[t]??void 0}}}}}}},"preserveDirectivesPlugin");export{S as preserveDirectivesPlugin};

package/dist/plugins/pure-new-expression-plugin.d.ts

@@ -0,0 +1,11 @@
+import type { Plugin } from "rollup";
+/**
+ * A Rollup plugin that adds `/*@__PURE__*\/` annotations before `new Constructor(...)` expressions
+ * for a given list of constructor names. This allows tree-shaking of unused instantiations.
+ *
+ * `rollup-plugin-pure` only handles `CallExpression` nodes; this plugin handles `NewExpression`.
+ */
+export declare const pureNewExpressionPlugin: (options: {
+    constructors: string[];
+    sourcemap?: boolean;
+}) => Plugin;

package/dist/plugins/raw.d.ts

@@ -0,0 +1,7 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin } from "rollup";
+export interface RawLoaderOptions {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+export declare const rawPlugin: (options: RawLoaderOptions) => Plugin;

package/dist/plugins/raw.js

@@ -0,0 +1,6 @@
+var i=Object.defineProperty;var n=(r,a)=>i(r,"name",{value:a,configurable:!0});import{createFilter as s}from"@rollup/pluginutils";import{readFile as u}from"@visulima/fs";var p=Object.defineProperty,d=n((r,a)=>p(r,"name",{value:a,configurable:!0}),"a");const g=d(r=>{const a=s(r.include,r.exclude);return{async load(t){if(t.includes("?raw")){const e=t.split("?")[0];try{const l=await u(e);return process.platform==="win32"?l.replaceAll(`\r
+`,`
+`):l}catch{this.error(`Failed to read file: ${e}`)}}return null},name:"packem:raw",transform(t,e){const l=e.includes("?raw"),o=l?e.split("?")[0]:e;if(a(o)||l){const c=process.platform==="win32"?t.replaceAll(`\r
+`,`
+`):t;return{code:`const data = ${JSON.stringify(c)};
+export default data;`,map:null}}return null}}},"rawPlugin");export{g as rawPlugin};

package/dist/plugins/require-cjs-transformer.d.ts

@@ -0,0 +1,43 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin, ResolvedId } from "rollup";
+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.
+ */
+export type TransformFunction = (
+/**
+ * The module ID (path) being imported.
+ */
+id: string, 
+/**
+ * The module ID (path) of the importer.
+ */
+importer: string, 
+/**
+ * Rollup resolve function for better module resolution
+ */
+rollupResolve: (id: string, importer?: string) => Promise<ResolvedId | null>) => Awaitable<boolean | undefined | void>;
+export 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" | undefined;
+    /**
+     * 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;
+}
+export declare const requireCJSTransformerPlugin: (userOptions: Options, _logger: Console) => Plugin;
+export {};

package/dist/plugins/require-cjs-transformer.js

@@ -0,0 +1,21 @@
+var E=Object.defineProperty;var w=(e,r)=>E(e,"name",{value:r,configurable:!0});import{createRequire as F,builtinModules as K}from"node:module";import B from"node:process";import{createFilter as L}from"@rollup/pluginutils";import{init as x,parse as G}from"cjs-module-lexer";import S from"magic-string";import{parseSync as H}from"oxc-parser";import{readFile as Q}from"@visulima/fs";import{findPackageJson as U}from"@visulima/package/package-json";var V=Object.defineProperty,X=w((e,r)=>V(e,"name",{value:r,configurable:!0}),"s");const Y=X(async(e,r,i)=>{if(await x(),e.startsWith("node:"))return!1;if(e.endsWith(".cjs"))return!0;if(e.endsWith(".js")||!e.includes("/")&&!e.startsWith(".")){let s;if(i)try{s=(await i(e,r))?.id}catch{}if(!s&&r&&!r.includes("!~{"))try{s=F(r).resolve(e)}catch{}if(s){try{const{packageJson:o}=await U(s);if(o.type==="module")return!1;if(o.type==="commonjs")return!0}catch{}try{const o=await Q(s,{encoding:"utf8"});try{return G(o,s),!0}catch{}}catch{}}}return!1},"isPureCJS");var Z=Object.defineProperty,m=w((e,r)=>Z(e,"name",{value:r,configurable:!0}),"c");const T="__cjs_require",z='import { createRequire as __cjs_createRequire } from "node:module";',ee=`const ${T} = __cjs_createRequire(import.meta.url);`,re='const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;',se=`const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return ${T}(module);
+};`,g={builtin:/const\s+__cjs_getBuiltinModule\s*=\s*\(module\)\s*=>\s*\{[\s\S]*?\};\s*/g,import:/import\s*\{\s*createRequire(?:\s+as\s+__cjs_createRequire)?\s*\}\s*from\s*["']node:module["'];?\s*/g,process:/const\s+__cjs_getProcess\s*=\s*typeof\s+globalThis[^;]*;\s*/g,require:/const\s+__cjs_require\s*=\s*(?:__cjs_)?createRequire\s*\([^)]*\);\s*/g};let R=!1;const te=m((e,r)=>r&&(K.includes(e)||e.startsWith("node:")),"isBuiltinModule"),oe=m(async(e,r,i,s,o)=>{if(r)return!0;const c=await i?.(e,s,o);return c===void 0?await Y(e,s,o):c},"shouldTransformImport"),ne=m((e,r)=>r?e==="process"||e==="node:process"?{code:"__cjs_getProcess",needsBuiltin:!1,needsProcess:!0,needsRequire:!0}:{code:`__cjs_getBuiltinModule(${JSON.stringify(e)})`,needsBuiltin:!0,needsProcess:!0,needsRequire:!0}:{code:`${T}(${JSON.stringify(e)})`,needsBuiltin:!1,needsProcess:!1,needsRequire:!0},"generateRequireCode"),ie=m(e=>{const r=new S(e),i={builtin:[...e.matchAll(g.builtin)],import:[...e.matchAll(g.import)],process:[...e.matchAll(g.process)],require:[...e.matchAll(g.require)]};return Object.values(i).forEach(s=>{if(s.length>1)for(let o=s.length-1;o>0;o-=1){const c=s[o];c&&r.remove(c.index,c.index+c[0].length)}}),r.toString()},"removeDuplicates"),ce=m(e=>{if(Array.isArray(e.shouldTransform)){const{shouldTransform:r}=e;e.shouldTransform=i=>r.includes(i)}return{builtinNodeModules:!!e.builtinNodeModules,cwd:e.cwd||B.cwd(),exclude:e.exclude||[/node_modules/,/\.d\.[cm]?ts$/],include:e.include||[/\.[cm]?[jt]sx?$/],order:"order"in e?e.order:"pre",shouldTransform:e.shouldTransform}},"resolveOptions"),he=m((e,r)=>{if(B.env.INTERNAL_PACKEM_BUILD)return{name:"require-cjs-transformer"};const{builtinNodeModules:i,cwd:s,exclude:o,include:c,order:A,shouldTransform:C}=ce(e),J=L(c,o);return{async buildStart(){R||(await x(),R=!0)},name:"packem:plugin-require-cjs",renderChunk:{async handler(h,M,O){if(O.format!=="es"||!J(M.fileName))return;const I=H(M.fileName,h,{astType:"js",lang:"js",sourceType:"module"}),u=new S(h);let j=!1,y=!1,v=!1;for await(const t of I.program.body){if(t.type!=="ImportDeclaration"||t.importKind==="type")continue;const l=t.source.value,d=te(l,i),$=this.resolve;if(!await oe(l,d,C,s,$))continue;const{code:b,needsBuiltin:k,needsProcess:W,needsRequire:D}=ne(l,d);if(j||=D,y||=W,v||=k,t.specifiers.length===0){d?u.remove(t.start,t.end):u.overwrite(t.start,t.end,`${b};`);continue}const P=[];let f,a;for(const n of t.specifiers)if(n.type==="ImportNamespaceSpecifier")f=n.local.name;else if(n.type==="ImportSpecifier"&&n.importKind!=="type"){const _=h.slice(n.imported.start,n.imported.end);P.push([_,n.local.name])}else n.type==="ImportDefaultSpecifier"&&(a=n.local.name);const p=[];if(f&&(a||=`_cjs_${f}_default`),a&&p.push(`const ${a} = ${b};`),f&&p.push(`const ${f} = { ...${a}, default: ${a} };`),P.length>0){const n=`const {
+${P.map(([_,q])=>`  ${_===q?q:`${_}: ${q}`}`).join(`,
+`)}
+} = ${a||b};`;p.push(n)}u.overwrite(t.start,t.end,p.join(`
+`))}if(j||y||v){const t=[];j&&t.push(z,ee),y&&t.push(re),v&&t.push(se);const l=`${t.join(`
+
+`)}
+
+`,d=u.toString();if(d[0]==="#"){const $=d.indexOf(`
+`)+1;u.appendLeft($,l)}else u.prepend(l)}const N=new S(ie(u.toString()));return{code:N.toString(),map:N.generateMap()}},order:A}}},"requireCJSTransformerPlugin");export{he as requireCJSTransformerPlugin};

package/dist/plugins/resolve-file-url.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "rollup";
+declare const resolveFileUrl: () => Plugin;
+export default resolveFileUrl;

package/dist/plugins/shebang.d.ts

@@ -0,0 +1,9 @@
+import type { Plugin } from "rollup";
+export type ShebangOptions = {
+    replace: boolean;
+    shebang: string;
+};
+export declare const makeExecutable: (filePath: string) => Promise<void>;
+export declare const shebangPlugin: (executablePaths: string[], options: ShebangOptions) => Plugin;
+export declare const removeShebangPlugin: () => Plugin;
+export declare const getShebang: (code: string, append?: string) => string;

package/dist/plugins/source-maps.d.ts

@@ -0,0 +1,7 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin } from "rollup";
+export interface SourcemapsPluginOptions {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+export declare const sourcemapsPlugin: ({ exclude, include }?: SourcemapsPluginOptions) => Plugin;

package/dist/plugins/sucrase/index.d.ts

@@ -1,19 +1,8 @@
-import '@rollup/pluginutils';
-import 'sucrase';
-export { M as SucrasePluginConfig, N as sucrasePlugin } from '../../packem_shared/types-yL82LLIx.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';
-import 'rollup-plugin-dts';
-import 'rollup-plugin-polyfill-node';
-import 'rollup-plugin-pure';
-import 'rollup-plugin-visualizer';
-import 'esbuild';
-import '@visulima/package';
-import '@visulima/packem-share/types';
-import 'oxc-resolver';
-import 'oxc-transform';
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { Options } from "sucrase";
+import type { TransformerFn as TransformerFunction } from "../../types.d.ts";
+export interface SucrasePluginConfig extends Options {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+export declare const sucrasePlugin: TransformerFunction;

package/dist/plugins/swc/index.d.ts

@@ -1,26 +1,2 @@
-import { T as TransformerFn, k as IsolatedDeclarationsResult } from '../../packem_shared/types-yL82LLIx.js';
-export { y as SwcPluginConfig } from '../../packem_shared/types-yL82LLIx.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 'rollup';
-import 'rollup-plugin-dts';
-import 'rollup-plugin-polyfill-node';
-import 'rollup-plugin-pure';
-import 'rollup-plugin-visualizer';
-import 'esbuild';
-import '@visulima/package';
-import '@visulima/packem-share/types';
-import 'oxc-resolver';
-import 'oxc-transform';
-import 'sucrase';
-
-declare const _default: TransformerFn;
-
-declare const isolatedDeclarationsSwcTransformer: (id: string, code: string, sourceMap?: boolean) => Promise<IsolatedDeclarationsResult>;
-
-export { isolatedDeclarationsSwcTransformer, _default as swcPlugin };
+export { default as swcPlugin } from "./swc-plugin.d.ts";
+export type * from "./types.d.ts";

package/dist/plugins/swc/index.js

@@ -0,0 +1 @@
+import{default as f}from"../../packem_shared/swcPlugin-Boip4lWG.js";export{f as swcPlugin};