@enhanced-dom/webpack 0.4.0 → 0.5.1

package/plugins/HtmlInlineSourcePlugin.js

@@ -0,0 +1,236 @@
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import path from 'path';
+// Ported from `escape-string-regexp` (inlined rather than taken as a dependency, since newer
+// majors of these tiny sindresorhus utils are ESM-only).
+// ATTRIBUTION: COPY | escape-string-regexp | Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com). MIT Licensed.
+const escapeRegExp = (value) => value.replace(/[|\\{}()[\]^$+*?.]/g, '\\$&');
+// Ported from `slash` (same reasoning as escapeRegExp above).
+// ATTRIBUTION: COPY | slash | Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com). MIT Licensed.
+// eslint-disable-next-line no-control-regex
+const toPosixPath = (value) => (/[^\x00-\x80]+/.test(value) ? value : value.replace(/\\/g, '/'));
+// Ported from `source-map-url` (same reasoning as escapeRegExp above); only the lookup this
+// plugin actually uses (`getFrom`) is kept.
+// ATTRIBUTION: COPY | source-map-url | Copyright 2014 Simon Lydell. X11 ("MIT") Licensed.
+const sourceMappingUrlRegExp = (() => {
+    const inner = `[#@] sourceMappingURL=([^\\s'"]*)`;
+    return new RegExp(`(?:/\\*(?:\\s*\r?\n(?://)?)?(?:${inner})\\s*\\*/|//(?:${inner}))\\s*`);
+})();
+const getSourceMappingUrl = (code) => {
+    const match = code.match(sourceMappingUrlRegExp);
+    return match ? match[1] || match[2] || '' : null;
+};
+// Inserts immediately before the real closing tag - found by taking the LAST match of
+// `</tagName>` in the document, not the first. An inlined <script>'s own source can legitimately
+// contain that same substring as plain text (e.g. an embedded HTML template string inside a
+// Worker's source, unrelated to actual document structure) well before the document's real
+// closing tag; matching the first occurrence would splice the insertion into the middle of that
+// script's text instead of after it, corrupting the script the browser was supposed to run.
+const insertBeforeClosingTag = (html, tagName, insertion) => {
+    const closingTagRegExp = new RegExp(`</${tagName}\\s*>`, 'gi');
+    let lastMatch = null;
+    let match;
+    while ((match = closingTagRegExp.exec(html))) {
+        lastMatch = match;
+    }
+    return lastMatch ? `${html.slice(0, lastMatch.index)}${insertion}${html.slice(lastMatch.index)}` : `${html}${insertion}`;
+};
+const buildAdditionalAssetMarkup = (wrapper, assetName, encoded) => {
+    if (wrapper === 'comment') {
+        return `<!--data-asset-name="${assetName}" data-encoding="base64" ${encoded}-->`;
+    }
+    return `<script type="application/octet-stream" data-asset-name="${assetName}" data-encoding="base64">${encoded}</script>`;
+};
+class HtmlInlineSourcePlugin {
+    assetsRegExp;
+    faviconPath;
+    htmlAssetName;
+    inlinedChunks;
+    additionalAssets;
+    // Rewrites a `//# sourceMappingURL=...`/`/*# sourceMappingURL=... */` comment (if any) in an
+    // asset's source to be relative to the site root instead of the asset's own directory, since
+    // inlining moves the asset's content into the html document rather than serving it from
+    // alongside its sourcemap.
+    // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.
+    // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.
+    resolveSourceMaps(compilation, assetName, asset) {
+        const source = asset.source();
+        const out = compilation.outputOptions;
+        const assetPath = path.join(out.path, assetName);
+        const sourceText = typeof source === 'string' ? source : source.toString();
+        const mapUrlOriginal = getSourceMappingUrl(sourceText);
+        if (!mapUrlOriginal || mapUrlOriginal.indexOf('data:') === 0 || mapUrlOriginal.indexOf('/') === 0) {
+            return sourceText;
+        }
+        const assetDir = path.dirname(assetPath);
+        const mapPath = path.join(assetDir, mapUrlOriginal);
+        const mapPathRelative = path.relative(out.path, mapPath);
+        const publicPath = typeof out.publicPath === 'string' ? out.publicPath : '';
+        const mapUrlCorrected = toPosixPath(path.join(publicPath, mapPathRelative));
+        const regex = new RegExp(`${escapeRegExp(mapUrlOriginal)}(\\s*(?:\\*/)?\\s*$)`);
+        return sourceText.replace(regex, (_match, group) => `${mapUrlCorrected}${group}`);
+    }
+    // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.
+    // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.
+    processTag(compilation, regex, tag) {
+        let assetUrl;
+        let resultTag = tag;
+        if (tag.tagName === 'script' && regex.test(tag.attributes.src)) {
+            assetUrl = tag.attributes.src;
+            resultTag = { tagName: 'script', voidTag: false, meta: {}, attributes: { type: 'text/javascript' } };
+        }
+        else if (tag.tagName === 'link' && regex.test(tag.attributes.href)) {
+            assetUrl = tag.attributes.href;
+            resultTag = { tagName: 'style', voidTag: false, meta: {}, attributes: { type: 'text/css' } };
+        }
+        if (assetUrl) {
+            const publicUrlPrefix = typeof compilation.outputOptions.publicPath === 'string' ? compilation.outputOptions.publicPath : '';
+            const assetName = path.posix.relative(publicUrlPrefix, assetUrl);
+            const asset = compilation.assets[assetName];
+            if (!asset) {
+                return resultTag;
+            }
+            const updatedSource = this.resolveSourceMaps(compilation, assetName, asset);
+            resultTag.innerHTML = resultTag.tagName === 'script' ? updatedSource.replace(/(<)(\/script>)/g, '\\x3C$2') : updatedSource;
+        }
+        return resultTag;
+    }
+    // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.
+    // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.
+    processTags(compilation, pluginData) {
+        const assetsRegExp = this.assetsRegExp;
+        if (!assetsRegExp) {
+            return pluginData;
+        }
+        const headTags = [];
+        const bodyTags = [];
+        const { publicPath } = compilation.outputOptions;
+        const publicUrlPrefix = typeof publicPath === 'string' ? publicPath : '';
+        // Mirrors processTag's own match condition (same regex, same tag-type checks) to record
+        // exactly which asset this tag will cause to be inlined, if any - without this, the
+        // processAssets hook below has no way to know which assets were actually touched. We record
+        // the owning CHUNK rather than the asset name: a chunk's identity is stable even when its
+        // contenthash (and therefore filename) is recomputed later by minification, so resolving
+        // `chunk.files` when deleting - instead of replaying a filename captured now - survives that
+        // timing gap.
+        const trackInlinedAsset = (tag) => {
+            let assetUrl;
+            if (tag.tagName === 'script' && assetsRegExp.test(tag.attributes.src)) {
+                assetUrl = tag.attributes.src;
+            }
+            else if (tag.tagName === 'link' && assetsRegExp.test(tag.attributes.href)) {
+                assetUrl = tag.attributes.href;
+            }
+            if (!assetUrl) {
+                return;
+            }
+            const assetName = path.posix.relative(publicUrlPrefix, assetUrl);
+            const owningChunk = Array.from(compilation.chunks).find((chunk) => chunk.files.has(assetName));
+            this.inlinedChunks = this.inlinedChunks ?? new Set();
+            this.inlinedChunks.add(owningChunk ?? assetName);
+        };
+        pluginData.headTags.forEach((tag) => {
+            trackInlinedAsset(tag);
+            headTags.push(this.processTag(compilation, assetsRegExp, tag));
+        });
+        pluginData.bodyTags.forEach((tag) => {
+            trackInlinedAsset(tag);
+            bodyTags.push(this.processTag(compilation, assetsRegExp, tag));
+        });
+        return { ...pluginData, headTags, bodyTags };
+    }
+    // Assets that exist in the compilation but were never referenced by a <script>/<link> tag (e.g.
+    // a license-notices file written directly via compilation.emitAsset) have nothing for
+    // processTags to match against - embed them explicitly instead, keyed by asset name so consuming
+    // code can read them back out of the DOM at runtime. `wrapper` picks the markup (an opaque,
+    // non-executing <script>, or a plain HTML comment - base64 never contains `--`, so it can't
+    // prematurely close the comment); `container` picks where it lands.
+    //
+    // This runs against the already-emitted HTML asset (see the processAssets hook below), not
+    // against pluginData inside afterTemplateExecution - some plugins that emit matchable assets
+    // (e.g. webpack-license-plugin, which writes its notices file at PROCESS_ASSETS_STAGE_ANALYSE)
+    // do so well after html-webpack-plugin has already rendered and emitted its HTML, so scanning
+    // compilation.assets from inside afterTemplateExecution would silently miss them. Since there's
+    // no headTags/bodyTags array to push a HtmlTagObject into at this point, 'script'-wrapped markup
+    // is spliced into the html string the same way 'comment'-wrapped markup already was.
+    processAdditionalAssets(compilation, html) {
+        let result = html;
+        const additionalAssets = this.additionalAssets ?? [];
+        additionalAssets.forEach(({ pattern, wrapper, container }) => {
+            Object.keys(compilation.assets)
+                .filter((name) => name !== this.htmlAssetName && pattern.test(name))
+                .forEach((name) => {
+                const encoded = compilation.assets[name].buffer().toString('base64');
+                this.inlinedChunks = this.inlinedChunks ?? new Set();
+                this.inlinedChunks.add(name);
+                const markup = buildAdditionalAssetMarkup(wrapper, name, encoded);
+                result = container === 'head' || container === 'body' ? insertBeforeClosingTag(result, container, markup) : `${result}${markup}`;
+            });
+        });
+        return result;
+    }
+    apply(compiler) {
+        this.assetsRegExp = undefined;
+        this.faviconPath = undefined;
+        this.inlinedChunks = new Set();
+        compiler.hooks.compilation.tap('html-inline-source-plugin', (compilation) => {
+            HtmlWebpackPlugin.getHooks(compilation).afterTemplateExecution.tapAsync('html-inline-source-plugin', (htmlPluginData, callback) => {
+                this.assetsRegExp = new RegExp('.(js|css)$');
+                this.htmlAssetName = htmlPluginData.outputName;
+                const result = this.processTags(compilation, htmlPluginData);
+                const favicon = htmlPluginData.plugin.options?.favicon;
+                const inputFs = compiler.inputFileSystem;
+                if (!favicon || !inputFs.existsSync(favicon)) {
+                    return callback(null, result);
+                }
+                const faviconTag = result.headTags.find((tag) => tag.tagName === 'link' && tag.attributes.rel === 'icon');
+                if (faviconTag) {
+                    this.faviconPath = faviconTag.attributes.href;
+                    faviconTag.attributes.href = `data:image/x-icon;base64, ${inputFs.readFileSync(favicon, 'base64')}`;
+                }
+                callback(null, result);
+            });
+            // Patches the already-emitted HTML asset directly (see processAdditionalAssets' own comment
+            // for why this can't happen inside afterTemplateExecution above) and must run strictly
+            // before the deletion pass below - same processAssets stage, but tapped first, so Tapable's
+            // stable same-stage ordering runs this one first.
+            compilation.hooks.processAssets.tap({ name: 'html-inline-source-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => {
+                if (!this.htmlAssetName)
+                    return;
+                const htmlAsset = compilation.assets[this.htmlAssetName];
+                if (!htmlAsset)
+                    return;
+                const html = this.processAdditionalAssets(compilation, htmlAsset.source().toString());
+                compilation.updateAsset(this.htmlAssetName, new compiler.webpack.sources.RawSource(html));
+            });
+            // Only remove assets that were actually inlined into the HTML above. Blanket-matching by
+            // extension would also delete unrelated .js/.css assets that were never inlining candidates
+            // in the first place - e.g. a Worker chunk, which browsers load via the separate Worker API
+            // rather than a <script> tag, so html-webpack-plugin never generates a tag for it.
+            // PROCESS_ASSETS_STAGE_REPORT is the last processAssets stage - it still runs before
+            // sealing freezes compilation.assets, so chunk.files here already reflects any earlier
+            // stage's rename (e.g. Terser's contenthash recompute).
+            compilation.hooks.processAssets.tap(
+            // Read the stage constant off compiler.webpack rather than importing Compilation as a
+            // value from 'webpack' directly - the plugin then keeps working correctly even if the
+            // host project resolves a different webpack instance than the one in this package's own
+            // node_modules (the standard reason webpack plugins avoid a direct `require('webpack')`).
+            { name: 'html-inline-source-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT }, () => {
+                this.inlinedChunks?.forEach((chunkOrName) => {
+                    if (typeof chunkOrName === 'string') {
+                        compilation.deleteAsset(chunkOrName);
+                        return;
+                    }
+                    chunkOrName.files.forEach((file) => {
+                        compilation.deleteAsset(file);
+                    });
+                });
+                const faviconFile = this.faviconPath?.split(path.sep)?.pop();
+                if (faviconFile) {
+                    compilation.deleteAsset(faviconFile);
+                }
+            });
+        });
+    }
+}
+export default HtmlInlineSourcePlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"HtmlInlineSourcePlugin.js","sourceRoot":"","sources":["../../src/plugins/HtmlInlineSourcePlugin.ts"],"names":[],"mappings":"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","sourcesContent":["import HtmlWebpackPlugin, { type Hooks, type HtmlTagObject } from 'html-webpack-plugin'\nimport { type AsyncSeriesWaterfallHook } from 'tapable'\nimport { type Chunk, type Compilation, type Compiler, type WebpackPluginInstance } from 'webpack'\nimport path from 'path'\n\ntype AsyncSeriesWaterfallHookDataType<T> = T extends AsyncSeriesWaterfallHook<infer R> ? R : never\ntype TemplateExecutionDataType = AsyncSeriesWaterfallHookDataType<Hooks['afterTemplateExecution']>\n\n// The compiler's inputFileSystem is only officially typed with async (callback) methods, but in\n// practice it's either Node's real `fs` or a MemoryFS - both also expose these Sync equivalents.\n// Same compromise WebcomponentStyleLoader.ts and @enhanced-dom/intl's webpack.plugin.ts make for\n// the same reason.\ninterface ISyncFileSystem {\n  existsSync: (pathOfItem: string) => boolean\n  readFileSync: (pathOfItem: string, encoding: string) => string\n}\n\n// Ported from `escape-string-regexp` (inlined rather than taken as a dependency, since newer\n// majors of these tiny sindresorhus utils are ESM-only).\n// ATTRIBUTION: COPY | escape-string-regexp | Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com). MIT Licensed.\nconst escapeRegExp = (value: string) => value.replace(/[|\\\\{}()[\\]^$+*?.]/g, '\\\\$&')\n\n// Ported from `slash` (same reasoning as escapeRegExp above).\n// ATTRIBUTION: COPY | slash | Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com). MIT Licensed.\n// eslint-disable-next-line no-control-regex\nconst toPosixPath = (value: string) => (/[^\\x00-\\x80]+/.test(value) ? value : value.replace(/\\\\/g, '/'))\n\n// Ported from `source-map-url` (same reasoning as escapeRegExp above); only the lookup this\n// plugin actually uses (`getFrom`) is kept.\n// ATTRIBUTION: COPY | source-map-url | Copyright 2014 Simon Lydell. X11 (\"MIT\") Licensed.\nconst sourceMappingUrlRegExp = (() => {\n  const inner = `[#@] sourceMappingURL=([^\\\\s'\"]*)`\n  return new RegExp(`(?:/\\\\*(?:\\\\s*\\r?\\n(?://)?)?(?:${inner})\\\\s*\\\\*/|//(?:${inner}))\\\\s*`)\n})()\nconst getSourceMappingUrl = (code: string) => {\n  const match = code.match(sourceMappingUrlRegExp)\n  return match ? match[1] || match[2] || '' : null\n}\n\n// Inserts immediately before the real closing tag - found by taking the LAST match of\n// `</tagName>` in the document, not the first. An inlined <script>'s own source can legitimately\n// contain that same substring as plain text (e.g. an embedded HTML template string inside a\n// Worker's source, unrelated to actual document structure) well before the document's real\n// closing tag; matching the first occurrence would splice the insertion into the middle of that\n// script's text instead of after it, corrupting the script the browser was supposed to run.\nconst insertBeforeClosingTag = (html: string, tagName: 'head' | 'body', insertion: string) => {\n  const closingTagRegExp = new RegExp(`</${tagName}\\\\s*>`, 'gi')\n  let lastMatch: RegExpExecArray | null = null\n  let match: RegExpExecArray | null\n  while ((match = closingTagRegExp.exec(html))) {\n    lastMatch = match\n  }\n  return lastMatch ? `${html.slice(0, lastMatch.index)}${insertion}${html.slice(lastMatch.index)}` : `${html}${insertion}`\n}\n\nconst buildAdditionalAssetMarkup = (wrapper: 'comment' | 'script', assetName: string, encoded: string) => {\n  if (wrapper === 'comment') {\n    return `<!--data-asset-name=\"${assetName}\" data-encoding=\"base64\" ${encoded}-->`\n  }\n  return `<script type=\"application/octet-stream\" data-asset-name=\"${assetName}\" data-encoding=\"base64\">${encoded}</script>`\n}\n\nclass HtmlInlineSourcePlugin implements WebpackPluginInstance {\n  assetsRegExp?: RegExp\n  faviconPath?: string\n  htmlAssetName?: string\n  inlinedChunks?: Set<Chunk | string>\n  additionalAssets?: { pattern: RegExp; wrapper: 'comment' | 'script'; container: 'head' | 'body' | 'footer' }[]\n\n  // Rewrites a `//# sourceMappingURL=...`/`/*# sourceMappingURL=... */` comment (if any) in an\n  // asset's source to be relative to the site root instead of the asset's own directory, since\n  // inlining moves the asset's content into the html document rather than serving it from\n  // alongside its sourcemap.\n  // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.\n  // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.\n  resolveSourceMaps(compilation: Compilation, assetName: string, asset: Compilation['assets'][string]): string {\n    const source = asset.source()\n    const out = compilation.outputOptions\n    const assetPath = path.join(out.path, assetName)\n    const sourceText = typeof source === 'string' ? source : source.toString()\n    const mapUrlOriginal = getSourceMappingUrl(sourceText)\n    if (!mapUrlOriginal || mapUrlOriginal.indexOf('data:') === 0 || mapUrlOriginal.indexOf('/') === 0) {\n      return sourceText\n    }\n    const assetDir = path.dirname(assetPath)\n    const mapPath = path.join(assetDir, mapUrlOriginal)\n    const mapPathRelative = path.relative(out.path, mapPath)\n    const publicPath = typeof out.publicPath === 'string' ? out.publicPath : ''\n    const mapUrlCorrected = toPosixPath(path.join(publicPath, mapPathRelative))\n    const regex = new RegExp(`${escapeRegExp(mapUrlOriginal)}(\\\\s*(?:\\\\*/)?\\\\s*$)`)\n    return sourceText.replace(regex, (_match, group) => `${mapUrlCorrected}${group}`)\n  }\n\n  // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.\n  // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.\n  processTag(compilation: Compilation, regex: RegExp, tag: HtmlTagObject): HtmlTagObject {\n    let assetUrl: string | undefined\n    let resultTag = tag\n\n    if (tag.tagName === 'script' && regex.test(tag.attributes.src as string)) {\n      assetUrl = tag.attributes.src as string\n      resultTag = { tagName: 'script', voidTag: false, meta: {}, attributes: { type: 'text/javascript' } }\n    } else if (tag.tagName === 'link' && regex.test(tag.attributes.href as string)) {\n      assetUrl = tag.attributes.href as string\n      resultTag = { tagName: 'style', voidTag: false, meta: {}, attributes: { type: 'text/css' } }\n    }\n\n    if (assetUrl) {\n      const publicUrlPrefix = typeof compilation.outputOptions.publicPath === 'string' ? compilation.outputOptions.publicPath : ''\n      const assetName = path.posix.relative(publicUrlPrefix, assetUrl)\n      const asset = compilation.assets[assetName]\n      if (!asset) {\n        return resultTag\n      }\n      const updatedSource = this.resolveSourceMaps(compilation, assetName, asset)\n      resultTag.innerHTML = resultTag.tagName === 'script' ? updatedSource.replace(/(<)(\\/script>)/g, '\\\\x3C$2') : updatedSource\n    }\n\n    return resultTag\n  }\n\n  // Adapted from `html-webpack-inline-source-plugin`'s method of the same name.\n  // ATTRIBUTION: ADAPTATION | html-webpack-inline-source-plugin | Copyright (c) 2016 Jan Nicklas. MIT Licensed.\n  processTags(compilation: Compilation, pluginData: TemplateExecutionDataType): TemplateExecutionDataType {\n    const assetsRegExp = this.assetsRegExp\n    if (!assetsRegExp) {\n      return pluginData\n    }\n    const headTags: typeof pluginData.headTags = []\n    const bodyTags: typeof pluginData.headTags = []\n\n    const { publicPath } = compilation.outputOptions\n    const publicUrlPrefix = typeof publicPath === 'string' ? publicPath : ''\n\n    // Mirrors processTag's own match condition (same regex, same tag-type checks) to record\n    // exactly which asset this tag will cause to be inlined, if any - without this, the\n    // processAssets hook below has no way to know which assets were actually touched. We record\n    // the owning CHUNK rather than the asset name: a chunk's identity is stable even when its\n    // contenthash (and therefore filename) is recomputed later by minification, so resolving\n    // `chunk.files` when deleting - instead of replaying a filename captured now - survives that\n    // timing gap.\n    const trackInlinedAsset = (tag: (typeof pluginData.headTags)[number]) => {\n      let assetUrl: string | undefined\n      if (tag.tagName === 'script' && assetsRegExp.test(tag.attributes.src as string)) {\n        assetUrl = tag.attributes.src as string\n      } else if (tag.tagName === 'link' && assetsRegExp.test(tag.attributes.href as string)) {\n        assetUrl = tag.attributes.href as string\n      }\n      if (!assetUrl) {\n        return\n      }\n      const assetName = path.posix.relative(publicUrlPrefix, assetUrl)\n      const owningChunk = Array.from(compilation.chunks).find((chunk) => chunk.files.has(assetName))\n      this.inlinedChunks = this.inlinedChunks ?? new Set()\n      this.inlinedChunks.add(owningChunk ?? assetName)\n    }\n\n    pluginData.headTags.forEach((tag) => {\n      trackInlinedAsset(tag)\n      headTags.push(this.processTag(compilation, assetsRegExp, tag))\n    })\n\n    pluginData.bodyTags.forEach((tag) => {\n      trackInlinedAsset(tag)\n      bodyTags.push(this.processTag(compilation, assetsRegExp, tag))\n    })\n\n    return { ...pluginData, headTags, bodyTags }\n  }\n\n  // Assets that exist in the compilation but were never referenced by a <script>/<link> tag (e.g.\n  // a license-notices file written directly via compilation.emitAsset) have nothing for\n  // processTags to match against - embed them explicitly instead, keyed by asset name so consuming\n  // code can read them back out of the DOM at runtime. `wrapper` picks the markup (an opaque,\n  // non-executing <script>, or a plain HTML comment - base64 never contains `--`, so it can't\n  // prematurely close the comment); `container` picks where it lands.\n  //\n  // This runs against the already-emitted HTML asset (see the processAssets hook below), not\n  // against pluginData inside afterTemplateExecution - some plugins that emit matchable assets\n  // (e.g. webpack-license-plugin, which writes its notices file at PROCESS_ASSETS_STAGE_ANALYSE)\n  // do so well after html-webpack-plugin has already rendered and emitted its HTML, so scanning\n  // compilation.assets from inside afterTemplateExecution would silently miss them. Since there's\n  // no headTags/bodyTags array to push a HtmlTagObject into at this point, 'script'-wrapped markup\n  // is spliced into the html string the same way 'comment'-wrapped markup already was.\n  processAdditionalAssets(compilation: Compilation, html: string): string {\n    let result = html\n\n    const additionalAssets = this.additionalAssets ?? []\n    additionalAssets.forEach(({ pattern, wrapper, container }) => {\n      Object.keys(compilation.assets)\n        .filter((name) => name !== this.htmlAssetName && pattern.test(name))\n        .forEach((name) => {\n          const encoded = compilation.assets[name]!.buffer().toString('base64')\n          this.inlinedChunks = this.inlinedChunks ?? new Set()\n          this.inlinedChunks.add(name)\n\n          const markup = buildAdditionalAssetMarkup(wrapper, name, encoded)\n          result = container === 'head' || container === 'body' ? insertBeforeClosingTag(result, container, markup) : `${result}${markup}`\n        })\n    })\n\n    return result\n  }\n\n  apply(compiler: Compiler) {\n    this.assetsRegExp = undefined\n    this.faviconPath = undefined\n    this.inlinedChunks = new Set<Chunk | string>()\n\n    compiler.hooks.compilation.tap('html-inline-source-plugin', (compilation) => {\n      HtmlWebpackPlugin.getHooks(compilation).afterTemplateExecution.tapAsync('html-inline-source-plugin', (htmlPluginData, callback) => {\n        this.assetsRegExp = new RegExp('.(js|css)$')\n        this.htmlAssetName = htmlPluginData.outputName\n        const result = this.processTags(compilation, htmlPluginData)\n\n        const favicon = htmlPluginData.plugin.options?.favicon\n        const inputFs = compiler.inputFileSystem as unknown as ISyncFileSystem\n        if (!favicon || !inputFs.existsSync(favicon)) {\n          return callback(null, result)\n        }\n        const faviconTag = result.headTags.find((tag) => tag.tagName === 'link' && tag.attributes.rel === 'icon')\n        if (faviconTag) {\n          this.faviconPath = faviconTag.attributes.href as string\n          faviconTag.attributes.href = `data:image/x-icon;base64, ${inputFs.readFileSync(favicon, 'base64')}`\n        }\n        callback(null, result)\n      })\n\n      // Patches the already-emitted HTML asset directly (see processAdditionalAssets' own comment\n      // for why this can't happen inside afterTemplateExecution above) and must run strictly\n      // before the deletion pass below - same processAssets stage, but tapped first, so Tapable's\n      // stable same-stage ordering runs this one first.\n      compilation.hooks.processAssets.tap(\n        { name: 'html-inline-source-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT },\n        () => {\n          if (!this.htmlAssetName) return\n          const htmlAsset = compilation.assets[this.htmlAssetName]\n          if (!htmlAsset) return\n          const html = this.processAdditionalAssets(compilation, htmlAsset.source().toString())\n          compilation.updateAsset(this.htmlAssetName, new compiler.webpack.sources.RawSource(html))\n        },\n      )\n\n      // Only remove assets that were actually inlined into the HTML above. Blanket-matching by\n      // extension would also delete unrelated .js/.css assets that were never inlining candidates\n      // in the first place - e.g. a Worker chunk, which browsers load via the separate Worker API\n      // rather than a <script> tag, so html-webpack-plugin never generates a tag for it.\n      // PROCESS_ASSETS_STAGE_REPORT is the last processAssets stage - it still runs before\n      // sealing freezes compilation.assets, so chunk.files here already reflects any earlier\n      // stage's rename (e.g. Terser's contenthash recompute).\n      compilation.hooks.processAssets.tap(\n        // Read the stage constant off compiler.webpack rather than importing Compilation as a\n        // value from 'webpack' directly - the plugin then keeps working correctly even if the\n        // host project resolves a different webpack instance than the one in this package's own\n        // node_modules (the standard reason webpack plugins avoid a direct `require('webpack')`).\n        { name: 'html-inline-source-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT },\n        () => {\n          this.inlinedChunks?.forEach((chunkOrName) => {\n            if (typeof chunkOrName === 'string') {\n              compilation.deleteAsset(chunkOrName)\n              return\n            }\n            chunkOrName.files.forEach((file) => {\n              compilation.deleteAsset(file)\n            })\n          })\n          const faviconFile = this.faviconPath?.split(path.sep)?.pop()\n          if (faviconFile) {\n            compilation.deleteAsset(faviconFile)\n          }\n        },\n      )\n    })\n  }\n}\n\nexport default HtmlInlineSourcePlugin\n"]}

package/plugins/SelfDecompressingHtmlPlugin.d.ts

@@ -0,0 +1,10 @@
+import { type Compiler, type WebpackPluginInstance } from 'webpack';
+declare class SelfDecompressingHtmlPlugin implements WebpackPluginInstance {
+    htmlAssetName?: string;
+    loadingMarkup: string;
+    constructor({ loadingMarkup }?: {
+        loadingMarkup?: string;
+    });
+    apply(compiler: Compiler): void;
+}
+export default SelfDecompressingHtmlPlugin;

package/plugins/SelfDecompressingHtmlPlugin.js

@@ -0,0 +1,119 @@
+import HtmlWebpackPlugin from 'html-webpack-plugin';
+import zlib from 'zlib';
+const gzip = (text) => new Promise((resolve, reject) => zlib.gzip(text, (err, buf) => (err ? reject(err) : resolve(buf))));
+const bodyRegExp = /<body([^>]*)>([\s\S]*)<\/body>/i;
+// Shown in place of the real body while it decompresses - a body this size can take a visible
+// moment to inflate, so leaving it blank would look broken. Overridable via the plugin's
+// `loadingMarkup` option; this default covers both the transient styling and the spinner markup
+// in one block, since neither has any meaning outside the other.
+const defaultLoadingMarkup = `<style>
+  :root { color-scheme: light dark; }
+  html, body { height: 100%; margin: 0; }
+  body {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: #fff;
+    color: #111;
+  }
+  @media (prefers-color-scheme: dark) {
+    body { background: #111; color: #eee; }
+  }
+  .spinner {
+    width: 2.5rem;
+    height: 2.5rem;
+    border: 3px solid rgba(128, 128, 128, 0.3);
+    border-top-color: currentColor;
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+  }
+  @keyframes spin {
+    to { transform: rotate(360deg); }
+  }
+</style>
+<div class="spinner"></div>`;
+// Inflates the gzipped, base64-encoded original body back into the page once it's ready, then
+// swaps it in for the loading markup above. Rebuilds any <script> nodes via createElement/
+// appendChild rather than assigning innerHTML/appendChild-ing template.content's parsed nodes
+// directly - browsers deliberately don't execute a <script> that arrives either way, only one
+// actually inserted via the DOM API, and the real body's inlined app bundle <script> has to run.
+const bootstrapScript = (base64) => `<script>
+(async () => {
+  try {
+    const bytes = Uint8Array.from(atob(${JSON.stringify(base64)}), (c) => c.charCodeAt(0))
+    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip'))
+    const bodyHtml = await new Response(stream).text()
+    const template = document.createElement('template')
+    template.innerHTML = bodyHtml
+    document.body.textContent = ''
+    Array.from(template.content.childNodes).forEach((node) => {
+      if (node.nodeName === 'SCRIPT') {
+        const script = document.createElement('script')
+        for (const attr of node.attributes) script.setAttribute(attr.name, attr.value)
+        script.textContent = node.textContent
+        document.body.appendChild(script)
+      } else {
+        document.body.appendChild(node)
+      }
+    })
+  } catch (err) {
+    document.body.textContent = 'Failed to decompress this page: ' + err.message
+  }
+})()
+</script>`;
+// Gzips an HTML asset's <body> content and replaces it with a small loading placeholder plus a
+// script that inflates and reinstates the original body client-side, via the browser's native
+// DecompressionStream - <head> (title, meta tags, favicon, any inlined <style>/<link>) is left
+// completely untouched, since html-webpack-plugin/htmlConfigFactory already built that correctly
+// and there's no reason to reconstruct it. Unlike a build-time-only gzip step (e.g. a .gz sidecar
+// file), this needs no server/Content-Encoding support to pay off - decompression happens
+// entirely client-side in the loaded page - so it works for content served statically or opened
+// directly from disk. Only replaces the body when the wrapped version actually comes out
+// smaller, since gzip + base64's ~33% overhead can lose against a small/already-dense body.
+class SelfDecompressingHtmlPlugin {
+    htmlAssetName;
+    loadingMarkup;
+    constructor({ loadingMarkup = defaultLoadingMarkup } = {}) {
+        this.loadingMarkup = loadingMarkup;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap('self-decompressing-html-plugin', (compilation) => {
+            // Capture the exact asset this plugin should act on - the one page the paired
+            // HtmlWebpackPlugin instance in this same htmlConfigFactory() call produced - the same way
+            // HtmlInlineSourcePlugin does. A pattern matched against all of compilation.assets (as an
+            // earlier version of this plugin did) would misfire in a multi-page build with several
+            // HtmlWebpackPlugin instances, touching pages this plugin instance has nothing to do with.
+            HtmlWebpackPlugin.getHooks(compilation).afterTemplateExecution.tap('self-decompressing-html-plugin', (htmlPluginData) => {
+                this.htmlAssetName = htmlPluginData.outputName;
+                return htmlPluginData;
+            });
+            // PROCESS_ASSETS_STAGE_REPORT is the last named processAssets stage - tapping a further
+            // 1000 past it, rather than at that same stage, guarantees this always runs after any
+            // other plugin's REPORT-stage work (e.g. an html-inlining plugin still rewriting the html
+            // asset at that same stage) regardless of plugin registration order, since this asset must
+            // be genuinely final before its body is gzipped.
+            compilation.hooks.processAssets.tapPromise({ name: 'self-decompressing-html-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000 }, async () => {
+                if (!this.htmlAssetName)
+                    return;
+                const htmlAsset = compilation.assets[this.htmlAssetName];
+                if (!htmlAsset)
+                    return;
+                const html = htmlAsset.source().toString();
+                const match = html.match(bodyRegExp);
+                if (!match)
+                    return;
+                const [fullMatch, bodyAttrs, bodyContent] = match;
+                if (bodyContent === undefined)
+                    return;
+                const gzipped = await gzip(bodyContent);
+                const newBody = `<body${bodyAttrs}>${this.loadingMarkup}${bootstrapScript(gzipped.toString('base64'))}</body>`;
+                const wrapped = html.slice(0, match.index) + newBody + html.slice(match.index + fullMatch.length);
+                if (wrapped.length >= html.length)
+                    return;
+                compilation.updateAsset(this.htmlAssetName, new compiler.webpack.sources.RawSource(wrapped));
+            });
+        });
+    }
+}
+export default SelfDecompressingHtmlPlugin;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SelfDecompressingHtmlPlugin.js","sourceRoot":"","sources":["../../src/plugins/SelfDecompressingHtmlPlugin.ts"],"names":[],"mappings":"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","sourcesContent":["import HtmlWebpackPlugin from 'html-webpack-plugin'\nimport { type Compilation, type Compiler, type WebpackPluginInstance } from 'webpack'\nimport zlib from 'zlib'\n\nconst gzip = (text: string): Promise<Buffer> =>\n  new Promise((resolve, reject) => zlib.gzip(text, (err, buf) => (err ? reject(err) : resolve(buf))))\n\nconst bodyRegExp = /<body([^>]*)>([\\s\\S]*)<\\/body>/i\n\n// Shown in place of the real body while it decompresses - a body this size can take a visible\n// moment to inflate, so leaving it blank would look broken. Overridable via the plugin's\n// `loadingMarkup` option; this default covers both the transient styling and the spinner markup\n// in one block, since neither has any meaning outside the other.\nconst defaultLoadingMarkup = `<style>\n  :root { color-scheme: light dark; }\n  html, body { height: 100%; margin: 0; }\n  body {\n    display: flex;\n    align-items: center;\n    justify-content: center;\n    background: #fff;\n    color: #111;\n  }\n  @media (prefers-color-scheme: dark) {\n    body { background: #111; color: #eee; }\n  }\n  .spinner {\n    width: 2.5rem;\n    height: 2.5rem;\n    border: 3px solid rgba(128, 128, 128, 0.3);\n    border-top-color: currentColor;\n    border-radius: 50%;\n    animation: spin 0.8s linear infinite;\n  }\n  @keyframes spin {\n    to { transform: rotate(360deg); }\n  }\n</style>\n<div class=\"spinner\"></div>`\n\n// Inflates the gzipped, base64-encoded original body back into the page once it's ready, then\n// swaps it in for the loading markup above. Rebuilds any <script> nodes via createElement/\n// appendChild rather than assigning innerHTML/appendChild-ing template.content's parsed nodes\n// directly - browsers deliberately don't execute a <script> that arrives either way, only one\n// actually inserted via the DOM API, and the real body's inlined app bundle <script> has to run.\nconst bootstrapScript = (base64: string) => `<script>\n(async () => {\n  try {\n    const bytes = Uint8Array.from(atob(${JSON.stringify(base64)}), (c) => c.charCodeAt(0))\n    const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream('gzip'))\n    const bodyHtml = await new Response(stream).text()\n    const template = document.createElement('template')\n    template.innerHTML = bodyHtml\n    document.body.textContent = ''\n    Array.from(template.content.childNodes).forEach((node) => {\n      if (node.nodeName === 'SCRIPT') {\n        const script = document.createElement('script')\n        for (const attr of node.attributes) script.setAttribute(attr.name, attr.value)\n        script.textContent = node.textContent\n        document.body.appendChild(script)\n      } else {\n        document.body.appendChild(node)\n      }\n    })\n  } catch (err) {\n    document.body.textContent = 'Failed to decompress this page: ' + err.message\n  }\n})()\n</script>`\n\n// Gzips an HTML asset's <body> content and replaces it with a small loading placeholder plus a\n// script that inflates and reinstates the original body client-side, via the browser's native\n// DecompressionStream - <head> (title, meta tags, favicon, any inlined <style>/<link>) is left\n// completely untouched, since html-webpack-plugin/htmlConfigFactory already built that correctly\n// and there's no reason to reconstruct it. Unlike a build-time-only gzip step (e.g. a .gz sidecar\n// file), this needs no server/Content-Encoding support to pay off - decompression happens\n// entirely client-side in the loaded page - so it works for content served statically or opened\n// directly from disk. Only replaces the body when the wrapped version actually comes out\n// smaller, since gzip + base64's ~33% overhead can lose against a small/already-dense body.\nclass SelfDecompressingHtmlPlugin implements WebpackPluginInstance {\n  htmlAssetName?: string\n  loadingMarkup: string\n\n  constructor({ loadingMarkup = defaultLoadingMarkup }: { loadingMarkup?: string } = {}) {\n    this.loadingMarkup = loadingMarkup\n  }\n\n  apply(compiler: Compiler) {\n    compiler.hooks.compilation.tap('self-decompressing-html-plugin', (compilation: Compilation) => {\n      // Capture the exact asset this plugin should act on - the one page the paired\n      // HtmlWebpackPlugin instance in this same htmlConfigFactory() call produced - the same way\n      // HtmlInlineSourcePlugin does. A pattern matched against all of compilation.assets (as an\n      // earlier version of this plugin did) would misfire in a multi-page build with several\n      // HtmlWebpackPlugin instances, touching pages this plugin instance has nothing to do with.\n      HtmlWebpackPlugin.getHooks(compilation).afterTemplateExecution.tap('self-decompressing-html-plugin', (htmlPluginData) => {\n        this.htmlAssetName = htmlPluginData.outputName\n        return htmlPluginData\n      })\n\n      // PROCESS_ASSETS_STAGE_REPORT is the last named processAssets stage - tapping a further\n      // 1000 past it, rather than at that same stage, guarantees this always runs after any\n      // other plugin's REPORT-stage work (e.g. an html-inlining plugin still rewriting the html\n      // asset at that same stage) regardless of plugin registration order, since this asset must\n      // be genuinely final before its body is gzipped.\n      compilation.hooks.processAssets.tapPromise(\n        { name: 'self-decompressing-html-plugin', stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_REPORT + 1000 },\n        async () => {\n          if (!this.htmlAssetName) return\n          const htmlAsset = compilation.assets[this.htmlAssetName]\n          if (!htmlAsset) return\n\n          const html = htmlAsset.source().toString()\n          const match = html.match(bodyRegExp)\n          if (!match) return\n\n          const [fullMatch, bodyAttrs, bodyContent] = match\n          if (bodyContent === undefined) return\n          const gzipped = await gzip(bodyContent)\n          const newBody = `<body${bodyAttrs}>${this.loadingMarkup}${bootstrapScript(gzipped.toString('base64'))}</body>`\n          const wrapped = html.slice(0, match.index) + newBody + html.slice(match.index! + fullMatch.length)\n          if (wrapped.length >= html.length) return\n\n          compilation.updateAsset(this.htmlAssetName, new compiler.webpack.sources.RawSource(wrapped))\n        },\n      )\n    })\n  }\n}\n\nexport default SelfDecompressingHtmlPlugin\n"]}

package/plugins/formatThirdPartyNotices.d.ts

@@ -0,0 +1,5 @@
+import type LicensePlugin from 'webpack-license-plugin';
+type AdditionalFilesConfigType = NonNullable<NonNullable<ConstructorParameters<typeof LicensePlugin>[0]>['additionalFiles']>;
+type PackageLicenseMetaType = Parameters<AdditionalFilesConfigType[string]>[0][number];
+declare const formatThirdPartyNotices: (packages: PackageLicenseMetaType[]) => string;
+export default formatThirdPartyNotices;

package/plugins/formatThirdPartyNotices.js

@@ -0,0 +1,11 @@
+const formatThirdPartyNotices = (packages) => packages
+    .slice()
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .map(({ name, version, license, author, repository, licenseText }) => {
+    const header = `${name}@${version} — ${license}${author ? ` — ${author}` : ''}${repository ? ` — ${repository}` : ''}`;
+    const body = (licenseText || '(license text unavailable)').trim();
+    return `${header}\n${'='.repeat(header.length)}\n\n${body}`;
+})
+    .join('\n\n\n');
+export default formatThirdPartyNotices;
+//# sourceMappingURL=data:application/json;base64,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

package/plugins/index.d.ts

@@ -1,23 +1,32 @@
 import { BundleAnalyzerPlugin } from 'webpack-bundle-analyzer';
+import LicensePlugin from 'webpack-license-plugin';
 import CssMinimizerPlugin from 'css-minimizer-webpack-plugin';
 import MiniCssExtractPlugin from 'mini-css-extract-plugin';
 import TerserPlugin from 'terser-webpack-plugin';
 import { MinifyOptions } from 'terser';
 import HtmlWebpackPlugin from 'html-webpack-plugin';
 import { type WebpackPluginInstance } from 'webpack';
+import DefineEnvPlugin from './DefineEnvPlugin.js';
+import HtmlInlineSourcePlugin from './HtmlInlineSourcePlugin.js';
+import SelfDecompressingHtmlPlugin from './SelfDecompressingHtmlPlugin.js';
 export declare const cssConfigFactory: ({ filename, cssnanoOptions, }?: {
     filename?: string;
     cssnanoOptions?: any;
 }) => (MiniCssExtractPlugin | CssMinimizerPlugin<CssMinimizerPlugin.CssNanoOptionsExtended>)[];
 export declare const bundleAnalyzerConfigFactory: (extraConfig?: BundleAnalyzerPlugin.Options) => BundleAnalyzerPlugin[];
-export declare const htmlConfigFactory: ({ html, embed }?: {
-    embed?: boolean;
+type HtmlInlineSourceAdditionalAssetsType = NonNullable<InstanceType<typeof HtmlInlineSourcePlugin>['additionalAssets']>;
+type SelfDecompressingHtmlOptionsType = ConstructorParameters<typeof SelfDecompressingHtmlPlugin>[0];
+export declare const htmlConfigFactory: ({ html, embed, compress, }?: {
+    embed?: boolean | {
+        additionalAssets?: HtmlInlineSourceAdditionalAssetsType;
+    };
+    compress?: boolean | SelfDecompressingHtmlOptionsType;
     html?: Partial<HtmlWebpackPlugin.Options>;
 }) => WebpackPluginInstance[];
 export declare const terserConfigFactory: ({ enableSourcemaps, terserOptions, embed }?: {
-    enableSourcemaps?: boolean;
-    terserOptions?: MinifyOptions;
-    embed?: boolean;
+    enableSourcemaps?: boolean | undefined;
+    terserOptions?: MinifyOptions | undefined;
+    embed?: boolean | undefined;
 }) => TerserPlugin<{
     compress: boolean | import("terser").CompressOptions;
     ecma?: import("terser").ECMA;
@@ -35,3 +44,6 @@ export declare const terserConfigFactory: ({ enableSourcemaps, terserOptions, em
     sourceMap: boolean | import("terser").SourceMapOptions;
     toplevel?: boolean;
 }>[];
+export declare const defineEnvConfigFactory: (envVarNames: string[]) => DefineEnvPlugin[];
+export declare const licenseConfigFactory: ({ outputFilename, includeNoticeText, additionalFiles, ...extraConfig }?: Partial<ConstructorParameters<typeof LicensePlugin>[0]>) => LicensePlugin[];
+export {};