@visulima/packem-rollup 1.0.0-alpha.3 → 1.0.0-alpha.30

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

@@ -1,25 +1,3 @@
-export { b as browserslistToEsbuild } from '../../packem_shared/browserslist-to-esbuild-DY9HwYtp.js';
-import { T as TransformerFn } from '../../packem_shared/types-C_grznAP.js';
-export { t as EsbuildPluginConfig, v as OptimizeDepsOptions, w as OptimizeDepsResult, O as Optimized, x as Options } from '../../packem_shared/types-C_grznAP.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;
-
-export { _default as esbuildPlugin };
+export { default as browserslistToEsbuild } from "./browserslist-to-esbuild.d.ts";
+export { default as esbuildPlugin } from "./esbuild-plugin.d.ts";
+export type * from "./types.d.ts";

package/dist/plugins/esbuild/index.js

@@ -0,0 +1 @@
+import{default as l}from"../../packem_shared/browserslistToEsbuild-C0IWmbNe.js";import{default as r}from"../../packem_shared/esbuildPlugin-DpLtQGuZ.js";export{l as browserslistToEsbuild,r as esbuildPlugin};

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

@@ -0,0 +1,39 @@
+/**
+ * Modified copy of https://github.com/egoist/rollup-plugin-esbuild/blob/dev/src/index.ts
+ *
+ * MIT License
+ *
+ * Copyright (c) 2020 EGOIST
+ */
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { BuildOptions as EsbuildOptions, Loader, TransformOptions } from "esbuild";
+type MarkOptional<Type, Keys extends keyof Type> = Type extends Type ? Omit<Type, Keys> & Partial<Pick<Type, Keys>> : never;
+export type EsbuildPluginConfig = Options & {
+    logger: Console;
+};
+export type Optimized = Map<string, {
+    file: string;
+}>;
+export type OptimizeDepsOptions = {
+    cwd: string;
+    esbuildOptions?: EsbuildOptions;
+    exclude?: string[];
+    include: string[];
+    sourceMap: boolean;
+};
+export type OptimizeDepsResult = {
+    cacheDir: string;
+    optimized: Optimized;
+};
+export type Options = Omit<TransformOptions, "loader" | "sourcemap"> & {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+    /**
+     * Map extension to esbuild loader
+     * Note that each entry (the extension) needs to start with a dot
+     */
+    loaders?: Record<string, Loader | false>;
+    optimizeDeps?: MarkOptional<OptimizeDepsOptions, "cwd" | "sourceMap">;
+    sourceMap?: boolean;
+};
+export {};

package/dist/plugins/esbuild/utils/get-render-chunk.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Modified copy of https://github.com/egoist/rollup-plugin-esbuild/blob/dev/src/minify.ts
+ *
+ * MIT License
+ *
+ * Copyright (c) 2020 EGOIST
+ */
+import type { TransformOptions } from "esbuild";
+import type { Plugin } from "rollup";
+type Options = Omit<TransformOptions, "sourcemap"> & {
+    sourceMap?: boolean;
+};
+declare const getRenderChunk: ({ sourceMap, ...options }: Options) => Plugin["renderChunk"];
+export default getRenderChunk;

package/dist/plugins/esbuild/utils/optimize-deps.d.ts

@@ -0,0 +1,3 @@
+import type { OptimizeDepsOptions, OptimizeDepsResult } from "../types.d.ts";
+declare const optimizeDeps: (options: OptimizeDepsOptions) => Promise<OptimizeDepsResult>;
+export default optimizeDeps;

package/dist/plugins/esbuild/utils/warn.d.ts

@@ -0,0 +1,4 @@
+import type { Message } from "esbuild";
+import type { PluginContext } from "rollup";
+declare const warn: (pluginContext: PluginContext, messages: Message[]) => Promise<void>;
+export default warn;

package/dist/plugins/esm-shim-cjs-syntax.d.ts

@@ -0,0 +1,9 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { PackageJson } from "@visulima/package";
+import type { Plugin } from "rollup";
+export declare const GLOBAL_REQUIRE_REGEX: RegExp;
+export interface EsmShimCjsSyntaxOptions {
+    exclude?: FilterPattern;
+    include?: FilterPattern;
+}
+export declare const esmShimCjsSyntaxPlugin: (packageJson: PackageJson, options: EsmShimCjsSyntaxOptions) => Plugin;

package/dist/plugins/fix-dts-default-cjs-exports.d.ts

@@ -0,0 +1,26 @@
+import type { Plugin, RenderedChunk } from "rollup";
+export type FixDtsDefaultCjsExportsPluginOptions = {
+    /**
+     * A function to determine if a chunk should be processed by this plugin.
+     * Defaults to processing .d.ts, .d.cts, or .d.mts files that are entry chunks and have exports.
+     * @param info The Rollup RenderedChunk object.
+     * @returns True if the chunk should be processed, false otherwise.
+     */
+    matcher?: (info: RenderedChunk) => boolean;
+};
+/**
+ * A Rollup plugin to fix default exports in TypeScript declaration files (.d.ts)
+ * to ensure they are CJS compatible (using `export = ...` and namespaces).
+ * This is particularly useful for libraries that want to support both ESM and CJS consumers correctly.
+ *
+ * The plugin handles various scenarios:
+ * - `export { MyClass as default };`
+ * - `export { default } from 'some-module';`
+ * - `export { name as default } from 'some-module';`
+ * - `export default from 'some-module';` (an mlly quirk)
+ * - Combinations with named exports (value and type exports), creating namespaces where appropriate.
+ * - Pure type-only exports like `export { type Foo, type Bar };`
+ * @param options Optional configuration for the plugin.
+ * @returns The Rollup plugin object.
+ */
+export declare const fixDtsDefaultCjsExportsPlugin: (options?: FixDtsDefaultCjsExportsPluginOptions) => Plugin;

package/dist/plugins/fix-dts-default-cjs-exports.js

@@ -0,0 +1 @@
+var i=Object.defineProperty;var n=(e,r)=>i(e,"name",{value:r,configurable:!0});import{_ as o}from"../packem_shared/fix-dts-default-cjs-exports-BQc0nwIG.js";var p=Object.defineProperty,a=n((e,r)=>p(e,"name",{value:r,configurable:!0}),"n");const l=a((e={})=>{const{matcher:r=a(t=>(t.type==="chunk"||t.type==="asset")&&t.exports?.length>0&&/\.d\.c?ts$/.test(t.fileName)&&t.isEntry,"matcher")}=e;return{name:"packem:fix-dts-default-cjs-exports-plugin",renderChunk(t,s){return r(s)?o(t,{fileName:s.fileName,imports:s.imports},{warn:this.warn}):void 0}}},"fixDtsDefaultCjsExportsPlugin");export{l as fixDtsDefaultCjsExportsPlugin};

package/dist/plugins/fix-dynamic-import-extension.d.ts

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

package/dist/plugins/isolated-declarations/index.d.ts

@@ -0,0 +1,8 @@
+import type { FilterPattern } from "@rollup/pluginutils";
+import type { BuildContext } from "@visulima/packem-share/types";
+import type { Plugin } from "rollup";
+export type IsolatedDeclarationsOptions = {
+    exclude?: FilterPattern;
+    ignoreErrors?: boolean;
+};
+export declare const isolatedDeclarationsPlugin: <T extends Record<string, any>>(sourceDirectory: string, context: BuildContext<T>) => Plugin;

package/dist/plugins/isolated-declarations/index.js

@@ -0,0 +1,3 @@
+var U=Object.defineProperty;var x=(t,e)=>U(t,"name",{value:e,configurable:!0});import{createFilter as X}from"@rollup/pluginutils";import{readFile as W}from"@visulima/fs";import{EXCLUDE_REGEXP as _,ENDING_REGEX as E}from"@visulima/packem-share/constants";import{getDtsExtension as L}from"@visulima/packem-share/utils";import{dirname as R,toNamespacedPath as D,sep as k,extname as J,isAbsolute as q,relative as C,join as A,basename as O}from"@visulima/path";import{parseSync as z}from"oxc-parser";import{_ as B}from"../../packem_shared/fix-dts-default-cjs-exports-BQc0nwIG.js";var H=Object.defineProperty,Q=x((t,e)=>H(t,"name",{value:e,configurable:!0}),"e");const P=/^([\w-]+):/,K=Q(t=>{if(!t||typeof t!="string")throw new Error("Invalid key: Key must be a non-empty string.");const e=[],c=P.exec(t);c&&(e.push(c[1]),t=t.replace(P,""));const n=t.split("/");for(const p of n)(p.includes("*")||p)&&e.push(p);return e},"splitTsconfigPathKey");var V=Object.defineProperty,Y=x((t,e)=>V(t,"name",{value:e,configurable:!0}),"h");const Z=Y((t,e)=>{const c=t.replace(/^\.\//,""),n=e.replace(/^\.\//,"");if(n.startsWith(c))return t+n.slice(c.length);if(t.endsWith(e))return t;const p=K(t),d=K(e);let l=p.length-1,r=d.length-1;for(;l>=0&&r>=0&&p[l]===d[r];)l--,r--;let a=p.slice(0,l).join("/");const f=d.slice(r).join("/");return(!a.startsWith(".")||a==="")&&(a=`./${a}`),a+(f?`/${f}`:"")},"extendString");var ee=Object.defineProperty,te=x((t,e)=>ee(t,"name",{value:e,configurable:!0}),"s");const re=te((...t)=>{if(t.length===0)return"";if(t.length===1)return R(t[0]);t=t.map(p=>D(p).split(k).join("/"));const[e,...c]=t;let n=e.split("/");for(const p of c){const d=p.split("/",n.length);let l=0;for(const r of d)if(r===n[l])l+=1;else{n=n.slice(0,l);break}n=n.slice(0,l)}return(n.length<=1&&n[0]===""?`/${n[0]}`:n.join("/")).split("/").join(k)},"lowestCommonAncestor");var ie=Object.defineProperty,j=x((t,e)=>ie(t,"name",{value:e,configurable:!0}),"g");const S=j((t,e)=>`${t}
+//# sourceMappingURL=${O(e)}.map
+`,"appendMapUrl"),I=j((t,e,c)=>JSON.stringify({file:O(c),mappings:t,names:[],sourceRoot:"",sources:[C(R(c),e)],version:3}),"generateDtsMap"),fe=j((t,e)=>{const c=X(/\.(?:[mc]?ts|[jt]sx?)$/,e.options.rollup.isolatedDeclarations?.exclude||_);let n=Object.create(null);const p=j((r,a)=>{n[r.replace(E,"")]={...a,ext:J(r)}},"addOutput");let d=[];e.tsconfig?.config.compilerOptions&&(d=Object.entries(e.tsconfig.config.compilerOptions.paths??{}).map(([r])=>r.endsWith("*")?new RegExp(`^${r.replace("*","(.*)")}$`):new RegExp(`^${r}$`)));async function l(r,a){if(!c(a))return;e.logger.debug({message:`Processing file: ${a}`,prefix:"packem:isolated-declarations"});let f;try{f=z(a,r).program}catch(s){e.logger.debug({message:s.message,prefix:"packem:isolated-declarations"})}if(f){const s=f.body.filter(i=>(i.type==="ImportDeclaration"||i.type==="ExportAllDeclaration"||i.type==="ExportNamedDeclaration")&&i.source);for await(const i of s){if(O(i.source.value).includes("."))continue;const o=await this.resolve(i.source.value,a);if(!(!o||o.external)&&(o.id.endsWith(".ts")||o.id.endsWith(".cts")||o.id.endsWith(".mts")||o.id.endsWith(".tsx")||o.id.endsWith(".ctsx")||o.id.endsWith(".mtsx"))){const g=o.id.replace(`${t}/`,"");let u=i.source.value;d.some($=>$.test(i.source.value))&&!i.source.value.startsWith(".")&&(u=`./${i.source.value}`),r=r.replaceAll(`from "${i.source.value}"`,`from "${Z(u,g)}"`)}}}const{errors:b,map:w,sourceText:m}=await e.options.isolatedDeclarationTransformer(a,r,e.options.sourcemap,e.tsconfig?.config?.compilerOptions);if(b.length>0){if(e.options.rollup.isolatedDeclarations.ignoreErrors){this.warn(b[0]);return}return this.error(b[0])}if(p(a,{map:w,source:m}),!f)return;const h=f.body.filter(s=>!("source"in s)||!s.source?!1:"importKind"in s&&s.importKind==="type"||"exportKind"in s&&s.exportKind==="type"?!0:s.type==="ImportDeclaration"?s.specifiers&&s.specifiers.every(i=>i.type==="ImportSpecifier"&&i.importKind==="type"):s.type==="ExportNamedDeclaration"&&s.specifiers&&s.specifiers.every(i=>i.exportKind==="type"));for await(const s of h){if(!s.source)continue;const i=await this.resolve(s.source.value,a);if(!i)return;const o=i.id;if(c(o)&&!n[o.replace(E,"")])try{const g=await W(o);await l.call(this,g,o)}catch{}}}return x(l,"N"),j(l,"transform"),{buildStart(){n=Object.create(null)},name:"packem:isolated-declarations",async renderStart(r,{input:a}){const f=re(...Array.isArray(a)?a:Object.values(a));e.logger.debug({message:`Input base:${f}`,prefix:"packem:isolated-declarations"});const b=Array.isArray(a)?a:Object.values(a);for await(const m of b)if(c(m)&&!n[m.replace(E,"")])try{const h=await W(m);await l.call(this,h,m)}catch{}typeof r.entryFileNames=="function"&&(r.entryFileNames=r.entryFileNames({name:r.name}));const w=r.entryFileNames.replace(/\.(.)?[jt]sx?$/,(m,h)=>`.d.${h||""}ts`);for await(let[m,{ext:h,map:s,source:i}]of Object.entries(n)){let o;if(q(m)){if(!m.startsWith(t)){e.logger.debug({message:`Skipping file outside sourceDirectory: ${m}`,prefix:"packem:isolated-declarations"});continue}o=C(t,m)}else o=m.replace(`${t}/`,"");if(o.startsWith("/")&&(o=o.slice(1)),e.options.rollup.cjsInterop&&r.format==="cjs"){const y=B(i,{fileName:o,imports:[]},{warn:this.warn});y&&(i=y.code)}const g=i.includes("from '")?"'":'"',u=o+h;if((e.options.declaration===!0||e.options.declaration==="compatible")&&r.format==="cjs"){e.logger.debug({message:`Emit compatible dts file: ${o}`,prefix:"packem:isolated-declarations"});const y=w.replace("[name]",D(o)).replace(".cts",".ts");let v=i;e.options.sourcemap&&s&&(v=S(v.trim(),y),this.emitFile({fileName:`${y}.map`,originalFileName:u,source:I(s,u,A(r.dir,y)),type:"asset"})),this.emitFile({fileName:y,originalFileName:u,source:v.replaceAll(/(from\s)['|"]((.*)\..+|['|"].*)['|"];?/g,(F,N,M,T)=>`${N+g+(T||M)}.d.ts${g};`),type:"asset"})}e.logger.debug({message:`Emit dts file: ${o}`,prefix:"packem:isolated-declarations"});const $=w.replace("[name]",D(o));e.options.sourcemap&&s&&(i=S(i.trim(),$),this.emitFile({fileName:`${$}.map`,originalFileName:u,source:I(s,u,A(r.dir,$)),type:"asset"}));const G=L(e,r.format==="cjs"?"cjs":"esm");this.emitFile({fileName:$,originalFileName:u,source:i.replaceAll(/(from\s)['|"]((.*)\..+|['|"].*)['|"];?/g,(y,v,F,N)=>`${v+g+(N||F)}.${G}${g};`),type:"asset"})}},transform:l}},"isolatedDeclarationsPlugin");export{fe as isolatedDeclarationsPlugin};

package/dist/plugins/isolated-declarations/utils/extend-string.d.ts

@@ -0,0 +1,2 @@
+declare const extendString: (baseString: string, referenceString: string) => string;
+export default extendString;

package/dist/plugins/isolated-declarations/utils/fix-dts-default-cjs-exports.d.ts

@@ -0,0 +1,35 @@
+import type { LoggingFunction, SourceMapInput } from "rollup";
+/**
+ * Options for the plugin.
+ */
+type Options = {
+    /**
+     * Rollup's warning function.
+     */
+    warn?: LoggingFunction;
+};
+/**
+ * Information about the code being processed.
+ */
+interface CodeInfo {
+    /**
+     * The name of the file.
+     */
+    fileName: string;
+    /**
+     * A list of import specifiers in the file.
+     */
+    imports: string[];
+}
+/**
+ * Main internal function to transform ES module default exports in .d.ts files to be CJS compatible.
+ * @param code The code of the chunk.
+ * @param info Information about the file (name, imports).
+ * @param options Plugin options, including the warning function.
+ * @returns An object with the transformed code and a null map, or undefined if no transformation occurs or an error happens.
+ */
+declare const fixDtsDefaultCJSExports: (code: string, info: CodeInfo, options: Options) => {
+    code: string;
+    map: SourceMapInput | undefined;
+} | undefined;
+export default fixDtsDefaultCJSExports;

package/dist/plugins/isolated-declarations/utils/lowest-common-ancestor.d.ts

@@ -0,0 +1,2 @@
+declare const lowestCommonAncestor: (...filepaths: string[]) => string;
+export default lowestCommonAncestor;

package/dist/plugins/isolated-declarations/utils/split-tsconfig-path-key.d.ts

@@ -0,0 +1,2 @@
+declare const splitTsconfigPathKey: (key: string) => string[];
+export default splitTsconfigPathKey;

package/dist/plugins/json.d.ts

@@ -0,0 +1,4 @@
+import type { RollupJsonOptions } from "@rollup/plugin-json";
+import type { Plugin } from "rollup";
+export type { RollupJsonOptions } from "@rollup/plugin-json";
+export declare const JsonPlugin: (options: RollupJsonOptions) => Plugin;

package/dist/plugins/json.js

@@ -0,0 +1 @@
+var c=Object.defineProperty;var t=(o,r)=>c(o,"name",{value:r,configurable:!0});import i from"@rollup/plugin-json";var l=Object.defineProperty,d=t((o,r)=>l(o,"name",{value:r,configurable:!0}),"t");const n="export default ",m=d(o=>{const r=i(o);return{...r,name:"packem:json",transform:{filter:{id:/\.json$/},handler(s,a){const e=r.transform?.call(this,s,a);return e&&typeof e!="string"&&"code"in e&&e.code?.startsWith(n)&&(e.code=e.code.replace(n,"module.exports = ")),e}}}},"JsonPlugin");export{m as JsonPlugin};

package/dist/plugins/jsx-remove-attributes.d.ts

@@ -0,0 +1,7 @@
+import type { Plugin } from "rollup";
+export type JSXRemoveAttributesPlugin = {
+    attributes: string[];
+};
+export declare const jsxRemoveAttributes: ({ attributes, logger }: JSXRemoveAttributesPlugin & {
+    logger: Console;
+}) => Plugin;

package/dist/plugins/jsx-remove-attributes.js

@@ -0,0 +1 @@
+var c=Object.defineProperty;var p=(e,a)=>c(e,"name",{value:a,configurable:!0});import{w as y}from"../packem_shared/index-Dq8IUFTs.js";import f from"magic-string";var b=Object.defineProperty,v=p((e,a)=>b(e,"name",{value:a,configurable:!0}),"l");const g=v(({attributes:e,logger:a})=>{if(!Array.isArray(e)||e.length===0)throw new Error("[packem:jsx-remove-attributes]: attributes must be a non-empty array of strings.");return{name:"packem:jsx-remove-attributes",transform:{filter:{id:/\.[tj]sx$/},async handler(i,u){let n;try{n=this.parse(i,{allowReturnOutsideFunction:!0})}catch(r){this.warn({code:"PARSE_ERROR",message:`[packem:jsx-remove-attributes]: failed to parse "${u}" and remove the jsx attribute.`}),a.warn(r);return}let l=!1;const o=new f(i);if(y(n,{enter(r){if(r.type==="CallExpression"&&r.callee.type==="Identifier"&&r.callee.name==="jsx"){const m=r.arguments.filter(s=>s.type==="ObjectExpression"&&Array.isArray(s.properties));for(const s of m)for(const t of s.properties)t.type==="Property"&&t.key.type==="Literal"&&t.value.type==="Literal"&&e.includes(t.key.value)&&(o.overwrite(t.start-2,t.end,""),l=!0)}}}),!!l)return{code:o.toString(),map:o.generateMap({hires:!0})}}}}},"jsxRemoveAttributes");export{g as jsxRemoveAttributes};

package/dist/plugins/license.d.ts

@@ -0,0 +1,17 @@
+import type { Plugin } from "rollup";
+export 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;
+}
+export declare const licensePlugin: ({ dtsMarker, licenseFilePath, licenseTemplate, logger, marker, mode, packageName, }: {
+    dtsMarker?: string;
+    licenseFilePath: string;
+    licenseTemplate: (licenses: string[], dependencyLicenseTexts: string, packageName: string | undefined) => string;
+    logger: Console;
+    marker: string;
+    mode: "dependencies" | "types";
+    packageName: string | undefined;
+}) => Plugin;

package/dist/plugins/license.js

@@ -0,0 +1,13 @@
+var P=Object.defineProperty;var h=(r,e)=>P(r,"name",{value:e,configurable:!0});import{readFileSync as b,writeFileSync as v}from"@visulima/fs";import{replaceContentWithinMarker as w}from"@visulima/packem-share/utils";import F from"rollup-plugin-license";var N=Object.defineProperty,y=h((r,e)=>N(r,"name",{value:e,configurable:!0}),"d");const C=y(r=>{const e=[],c=[];return r.forEach(t=>{t.startsWith("(")?e.push(t):c.push(t)}),[...c.toSorted(),...e.toSorted()]},"sortLicenses"),z=y(({dtsMarker:r,licenseFilePath:e,licenseTemplate:c,logger:t,marker:s,mode:m,packageName:S})=>F({thirdParty(x){const u=new Set,d=x.toSorted(({name:n},{name:i})=>(n||0)>(i||0)?1:(i||0)>(n||0)?-1:0).map(({author:n,contributors:i,license:a,licenseText:$,maintainers:j,name:k,repository:p})=>{let l=`## ${k}
+`;a&&(l+=`License: ${a}
+`);const f=new Set;for(const o of[n,...j,...i]){const g=typeof o=="string"?o:o?.name;g&&f.add(g)}return f.size>0&&(l+=`By: ${[...f].join(", ")}
+`),p&&(l+=`Repository: ${typeof p=="string"?p:p.url}
+`),$&&(l+=`
+${$.trim().replaceAll(/\r\n|\r/g,`
+`).replaceAll(`<!-- ${s} -->`,"").replaceAll(r?`<!-- ${r} -->`:"","").replaceAll(`<!-- /${s} -->`,"").replaceAll(r?`<!-- /${r} -->`:"","").trim().split(`
+`).map(o=>o?`> ${o}`:">").join(`
+`)}
+`),a&&u.add(a),l}).join(`
+---------------------------------------
+
+`);if(d===""){t.info({message:"No dependencies license information found.",prefix:`plugin:license:${m}`});return}const A=c(C(u),d,S);try{const n=b(e),i=w(n,s,A);if(!i){t.error({message:`Could not find the license marker: <!-- ${s} --><!-- /${s} --> in ${e}`,prefix:`plugin:license:${m}`});return}n!==i&&(v(e,i),t.info({message:`${e} updated.`,prefix:`plugin:license:${m}`}))}catch(n){t.error(n)}}}),"licensePlugin");export{z as licensePlugin};

package/dist/plugins/metafile.d.ts

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

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

@@ -0,0 +1,41 @@
+/**
+ * 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 { FilterPattern } from "@rollup/pluginutils";
+import type { Plugin } from "rollup";
+import * as minify from "./lib/minify-html-literals.d.ts";
+/**
+ * Plugin options.
+ */
+export 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 minify.minifyHTMLLiterals;
+    /**
+     * Minify options, see
+     * https://www.npmjs.com/package/minify-html-literals#options.
+     */
+    options?: Partial<minify.Options>;
+}
+export declare const minifyHTMLLiteralsPlugin: ({ exclude, failOnError, include, logger, minifyHTMLLiterals, options, }: MinifyHTMLLiteralsOptions & {
+    logger: Console;
+}) => Plugin;
+export default minifyHTMLLiteralsPlugin;

package/dist/plugins/minify-html-literals/index.js

@@ -0,0 +1,3 @@
+var b=Object.defineProperty;var g=(t,e)=>b(t,"name",{value:e,configurable:!0});import{createFilter as E}from"@rollup/pluginutils";import H from"magic-string";import p from"typescript";import N from"clean-css";import{minify as j}from"html-minifier-next";let y;const A={getHeadTemplatePart(t){const e=t.getFullText(y),i=e.indexOf("`")+1,r=p.isTemplateHead(t)?-2:-1;return{end:t.end+r,start:t.pos+i,text:e.slice(i,e.length+r)}},getMiddleTailTemplatePart(t){const e=t.getText(y),i=p.isTemplateMiddle(t)?2:1;return{end:t.end-i,start:t.getStart(y)+1,text:e.slice(1,e.length-i)}},getRootNode(t,e=""){return p.createSourceFile(e,t,p.ScriptTarget.ESNext)},getTaggedTemplateTemplate(t){return t.template},getTagText(t){return t.tag.getText(y)},getTemplateParts(t){return p.isNoSubstitutionTemplateLiteral(t)?[this.getHeadTemplatePart(t)]:[this.getHeadTemplatePart(t.head),...t.templateSpans.map(e=>this.getMiddleTailTemplatePart(e.literal))]},isTaggedTemplate:p.isTaggedTemplateExpression,isTemplate:p.isTemplateLiteral,walkChildNodes(t,e){e(t),p.forEachChild(t,i=>{this.walkChildNodes(i,e)})},walkNodes(t,e){y=t,this.walkChildNodes(t,e),y=void 0}};var k=Object.defineProperty,V=g((t,e)=>k(t,"name",{value:e,configurable:!0}),"i");const W=V((t,e={})=>{const i={...A,...e.strategy},r=[],s=[];return i.walkNodes(i.getRootNode(t,e.fileName),a=>{if(i.isTaggedTemplate(a)){const n=i.getTaggedTemplateTemplate(a);s.push(n),r.push({parts:i.getTemplateParts(n),tag:i.getTagText(a)})}else i.isTemplate(a)&&!s.includes(a)&&r.push({parts:i.getTemplateParts(a)})}),r},"parseLiterals");var $=Object.defineProperty,C=g((t,e)=>$(t,"name",{value:e,configurable:!0}),"f");const S={One:"1",Two:"2",Zero:"0"},F=C(t=>{const e={[S.One]:{tidySelectors:!1,transform:void 0},[S.Two]:{tidySelectors:!1,transform:void 0},[S.Zero]:{}};if(t===void 0)return e;if(typeof t=="number"){const i=t.toString();return{...e,[i]:{...e[i]}}}return t},"optimizationLevelFrom"),P=C((t,e)=>{const i=/(:.+\((.*)\))\s*\{/g;let r;for(;(r=i.exec(t))!==null;){const s=r[1],a=r[2];if(!s||!a||!/\s/.test(a))continue;const n=a.replaceAll(/\s/g,""),o=s.replace(a,n),f=e.indexOf(o);if(f===-1)continue;const u=f+o.length;e=e.slice(0,Math.max(0,f))+s+e.slice(Math.max(0,u))}return e},"fixCleanCssTidySelectors"),R={},B={caseSensitive:!0,collapseWhitespace:!0,decodeEntities:!0,minifyCSS:R,minifyJS:!0,processConditionalComments:!0,removeAttributeQuotes:!1,removeComments:!0,removeEmptyAttributes:!0,removeScriptTypeAttributes:!0,removeStyleLinkTypeAttributes:!0,useShortDoctype:!0},x=C((t={})=>{const e=F(t.level),i=typeof t.level=="object"&&t.level[1]&&t.level[1].transform;return e[S.One].transform=(r,s)=>s.startsWith("@TEMPLATE_EXPRESSION")&&!s.endsWith(";")?s=`${s};`:i?i(r,s):s,{...t,level:e}},"adjustMinifyCSSOptions"),_={combineHTMLStrings(t,e){return t.map(i=>i.text).join(e)},getPlaceholder(t){let e="@TEMPLATE_EXPRESSION";for(;t.some(i=>i.text.includes(e+"();"));)e+="_";return e+"();"},minifyCSS(t,e={}){const i=x(e),r=new N(i).minify(t);if(r.errors&&r.errors.length>0)throw new Error(r.errors.join(`
+
+`));return i.level[S.One].tidySelectors&&(r.styles=P(t,r.styles)),r.styles},async minifyHTML(t,e={}){let i;e.minifyCSS?i=e.minifyCSS!==!0&&typeof e.minifyCSS!="function"?{...e.minifyCSS}:{}:i=!1;let r=!1;i&&(r=x(i));let s=await j(t,{...e,minifyCSS:r});if(e.collapseWhitespace){const a=[...s.matchAll(/<svg/g)].reverse();for(const n of a){const o=n.index,f=s.indexOf("</svg",o);if(f===-1)continue;const u=s.slice(0,Math.max(0,o));let l=s.substring(o,f);const d=s.slice(Math.max(0,f));l=l.replaceAll(/\r?\n/g,""),s=u+l+d}}return r&&r.level[S.One].tidySelectors&&(s=P(t,s)),s},splitHTMLByPlaceholder(t,e){const i=t.split(e);if(e.endsWith(";")){const r=e.slice(0,Math.max(0,e.length-1));for(let s=i.length-1;s>=0;s--){const a=i[s];a!==void 0&&i.splice(s,1,...a.split(r))}}return i}};var G=Object.defineProperty,M=g((t,e)=>G(t,"name",{value:e,configurable:!0}),"l");const I=M((t,e)=>t.generateMap({file:`${e}.map`,hires:!0,source:e}),"defaultGenerateSourceMap"),X=M(t=>{const e=t.tag&&t.tag.toLowerCase();return!!e&&(e.includes("html")||e.includes("svg"))},"defaultShouldMinify"),Z=M(t=>!!t.tag&&t.tag.toLowerCase().includes("css"),"defaultShouldMinifyCSS"),z={ensureHTMLPartsValid(t,e){if(t.length!==e.length)throw new Error("splitHTMLByPlaceholder() must return same number of strings as template parts")},ensurePlaceholderValid(t){if(typeof t!="string"||t.length===0)throw new Error("getPlaceholder() must return a non-empty string")}};async function w(t,e={}){e.minifyOptions={...B,...e.minifyOptions},e.MagicString||(e.MagicString=H),e.parseLiterals||(e.parseLiterals=W),e.shouldMinify||(e.shouldMinify=X),e.shouldMinifyCSS||(e.shouldMinifyCSS=Z),e.parseLiteralsOptions={fileName:e.fileName,...e.parseLiteralsOptions};const i=e.parseLiterals(t,e.parseLiteralsOptions),r=e.strategy||_,{shouldMinify:s,shouldMinifyCSS:a}=e;let n;e.validate!==!1&&(n=e.validate||z);const o=new e.MagicString(t);for(const l of i){const d=s(l),O=!!r.minifyCSS&&a(l);if(d||O){const v=r.getPlaceholder(l.parts);n&&n.ensurePlaceholderValid(v);const T=r.combineHTMLStrings(l.parts,v);let h;if(O){const c=(e.minifyOptions||{}).minifyCSS;if(typeof c=="function"){const m=c(T);h=typeof m=="string"?m:await m}else if(c===!1)h=T;else{const m=typeof c=="object"?c:void 0;h=await r.minifyCSS(T,m)}}else h=await r.minifyHTML(T,e.minifyOptions);const L=r.splitHTMLByPlaceholder(h,v);n&&n.ensureHTMLPartsValid(l.parts,L),l.parts.forEach((c,m)=>{c.start<c.end&&L[m]!==void 0&&o.overwrite(c.start,c.end,L[m])})}}const f=o.toString();if(t===f)return;let u;return e.generateSourceMap!==!1&&(u=(e.generateSourceMap||I)(o,e.fileName??"")),{code:f,map:u}}g(w,"minifyHTMLLiterals");M(w,"minifyHTMLLiterals");var D=Object.defineProperty,J=g((t,e)=>D(t,"name",{value:e,configurable:!0}),"o");const te=J(({exclude:t,failOnError:e=!1,include:i,logger:r,minifyHTMLLiterals:s,options:a})=>{s||(s=w);const n=E(i,t),o=a||{};return{name:"packem:minify-html-literals",async transform(f,u){if(n(u))try{return await s(f,{...o,fileName:u})}catch(l){const d=l instanceof Error?l.message:l;e?this.error(d):r.warn({message:d,prefix:"plugin:minify-html-literals"})}}}},"minifyHTMLLiteralsPlugin");export{te as default,te as minifyHTMLLiteralsPlugin};

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>;
+/**
+ * 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[];