ultimate-jekyll-manager 0.0.93 → 0.0.94

package/dist/commands/minify-html.js

@@ -0,0 +1,19 @@
+// Libraries
+const Manager = new (require('../build.js'));
+const logger = Manager.logger('minify');
+const { execute } = require('node-powertools');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+
+module.exports = async function (options) {
+  // Log
+  logger.log(`Starting minify...`);
+
+  // Build environment variables with all options
+  const envVars = `UJ_MINIFY_HTML_FORCE=true`;
+
+  // Run the full build process with minify force enabled
+  await execute(`${envVars} bundle exec npm run gulp -- minifyHtml`, { log: true })
+};

package/dist/gulp/tasks/minifyHtml.js

@@ -2,7 +2,8 @@
 const Manager = new (require('../../build.js'));
 const logger = Manager.logger('minifyHtml');
 const { src, dest, series } = require('gulp');
-const { minify } = require('html-minifier-terser');
+const { minify: minifyRust } = require('@minify-html/node');
+const { minify: minifyJs } = require('terser');
 const through2 = require('through2');
 
 // Load package
@@ -19,6 +20,33 @@ const input = [
 ];
 const output = '_site';
 
+// Helper function to minify a single file's content using Rust-based minifier
+async function minifyFileContent(htmlContent, options, filePath) {
+  // Extract and temporarily replace JSON-LD scripts
+  const { content: contentAfterJsonLd, extracted: jsonLdScripts } = extractJsonLdScripts(htmlContent);
+
+  // Extract and temporarily replace inline scripts (minified with Terser)
+  const { content: contentAfterScripts, extracted: inlineScripts } = await extractInlineScripts(contentAfterJsonLd, filePath);
+
+  // Extract and temporarily replace IE conditional comments
+  const { content: contentAfterComments, extracted: conditionalComments } = extractConditionalComments(contentAfterScripts);
+
+  // Minify the HTML content using Rust-based minifier (synchronous, much faster)
+  const minifiedBuffer = minifyRust(Buffer.from(contentAfterComments), options);
+  const minified = minifiedBuffer.toString();
+
+  // Restore the conditional comments
+  let finalHtml = restoreConditionalComments(minified, conditionalComments);
+
+  // Restore the inline scripts
+  finalHtml = restoreInlineScripts(finalHtml, inlineScripts);
+
+  // Restore the JSON-LD scripts
+  finalHtml = restoreJsonLdScripts(finalHtml, jsonLdScripts);
+
+  return finalHtml;
+}
+
 // Main task
 function minifyHtmlTask(complete) {
   // Check if we should minify
@@ -33,92 +61,248 @@ function minifyHtmlTask(complete) {
   logger.log('Starting...');
   Manager.logMemory(logger, 'Start');
 
-  // Configure minify options
+  // Configure minify options for @minify-html/node (Rust-based)
+  // NOTE: Inline scripts are extracted before minification to avoid bugs in minify-js
   const options = {
-    collapseWhitespace: true,
-    removeComments: true,
-    removeAttributeQuotes: true,
-    removeRedundantAttributes: true,
-    removeScriptTypeAttributes: true,
-    removeStyleLinkTypeAttributes: true,
-    useShortDoctype: true,
-    removeEmptyAttributes: true,
-    removeOptionalTags: false,
-    minifyCSS: true,
-    minifyJS: true
+    keep_closing_tags: false,
+    keep_comments: false,
+    keep_html_and_head_opening_tags: false,
+    keep_spaces_between_attributes: false,
+    keep_ssi_comments: false,
+    minify_css: true,
+    minify_js: false, // Disabled - inline scripts are extracted, so nothing to minify
+    remove_bangs: false,
+    remove_processing_instructions: false
   };
 
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '1', 10);
+  logger.log(`Concurrency: ${CONCURRENCY_LIMIT} files at a time`);
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
   // Process HTML files
   return src(input)
-    .pipe(through2.obj(async function(file, enc, callback) {
+    .pipe(through2.obj(function(file, _enc, callback) {
       if (file.isBuffer()) {
-        try {
-          let htmlContent = file.contents.toString();
-
-          // Extract and temporarily replace JSON-LD scripts
-          const jsonLdScripts = [];
-          const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
-
-          htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
-            // Minify the JSON content
-            try {
-              const parsed = JSON.parse(jsonContent);
-              const minifiedJson = JSON.stringify(parsed);
-              jsonLdScripts.push(minifiedJson);
-            } catch (e) {
-              jsonLdScripts.push(jsonContent);
-            }
-            return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
-          });
-
-          // Extract and temporarily replace IE conditional comments
-          const conditionalComments = [];
-          const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
-
-          htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
-            // Minify the content inside the conditional comment
-            try {
-              const minifiedContent = content
-                .replace(/\s+/g, ' ')
-                .replace(/>\s+</g, '><')
-                .trim();
-              conditionalComments.push(match.replace(content, minifiedContent));
-            } catch (e) {
-              conditionalComments.push(match);
-            }
-            return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
-          });
-
-          // Minify the HTML content
-          const minified = await minify(htmlContent, options);
-
-          // Restore the JSON-LD scripts and conditional comments
-          let finalHtml = minified;
-          jsonLdScripts.forEach((jsonContent, index) => {
-            const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
-            finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
-          });
-
-          conditionalComments.forEach((commentContent, index) => {
-            finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
-          });
-
-          file.contents = Buffer.from(finalHtml);
-        } catch (err) {
-          logger.error(`Error minifying ${file.path}: ${err.message}`);
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+
+          // Process batch in parallel
+          const processedFiles = await Promise.all(
+            batch.map(async ({ file }) => {
+              try {
+                const htmlContent = file.contents.toString();
+                const finalHtml = await minifyFileContent(htmlContent, options, file.path);
+                file.contents = Buffer.from(finalHtml);
+                processed.count++;
+
+                // Log progress every 50 files or on last file
+                if (processed.count % 50 === 0 || processed.count === totalFiles) {
+                  const percentage = ((processed.count / totalFiles) * 100).toFixed(1);
+                  logger.log(`Progress: ${processed.count}/${totalFiles} files (${percentage}%)`);
+                  Manager.logMemory(logger, `After ${processed.count} files`);
+                }
+
+                return file;
+              } catch (err) {
+                logger.error(`Error minifying ${file.path}: ${err.message}`);
+                return file;
+              }
+            })
+          );
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
         }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
       }
-      callback(null, file);
     }))
     .pipe(dest(output))
     .on('finish', () => {
       // Log
       logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
 
       // Complete
-      return complete();
+      complete();
     });
 }
 
+// Helper: Extract JSON-LD scripts and replace with placeholders
+function extractJsonLdScripts(htmlContent) {
+  const extracted = [];
+  // Match both quoted and unquoted type attributes (minifier removes quotes)
+  const jsonLdRegex = /<script[^>]*type=(?:["']?application\/ld\+json["']?)[^>]*>([\s\S]*?)<\/script>/gi;
+
+  const content = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      extracted.push(minifiedJson);
+    } catch (e) {
+      extracted.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore JSON-LD scripts from placeholders
+function restoreJsonLdScripts(htmlContent, jsonLdScripts) {
+  let content = htmlContent;
+
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    content = content.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  return content;
+}
+
+// Helper: Extract inline scripts, minify with Terser, and replace with placeholders
+async function extractInlineScripts(htmlContent, filePath) {
+  const extracted = [];
+  const scripts = [];
+
+  // Match <script> tags that are NOT application/ld+json (those are already extracted)
+  // This regex excludes external scripts (those with src attribute)
+  // Handles both quoted and unquoted type attributes (minifier removes quotes)
+  const scriptRegex = /<script(?![^>]*type=(?:["']?application\/ld\+json["']?))(?![^>]*src=)([^>]*)>([\s\S]*?)<\/script>/gi;
+
+  // First pass: collect all scripts and create placeholders
+  const content = htmlContent.replace(scriptRegex, (fullMatch, attributes, jsCode) => {
+    const index = scripts.length;
+    scripts.push({ fullMatch, attributes, jsCode });
+    return `__INLINE_SCRIPT_PLACEHOLDER_${index}__`;
+  });
+
+  // Second pass: minify all scripts in parallel
+  const minifyPromises = scripts.map(async ({ fullMatch, attributes, jsCode }, scriptIndex) => {
+    // Skip empty scripts
+    if (!jsCode.trim()) {
+      return fullMatch;
+    }
+
+    // Try to minify the JavaScript with Terser
+    try {
+      const minified = await minifyJs(jsCode, {
+        compress: {
+          dead_code: true,
+          drop_console: false,
+          drop_debugger: true,
+          keep_classnames: false,
+          keep_fargs: true,
+          keep_fnames: false,
+          keep_infinity: false,
+        },
+        mangle: false, // Don't mangle variable names to avoid breaking code
+        format: {
+          comments: false,
+        },
+      });
+
+      if (minified && minified.code) {
+        return `<script${attributes}>${minified.code}</script>`;
+      }
+
+      return fullMatch;
+    } catch (err) {
+      // Minification failed - use original and log detailed error
+      const preview = jsCode.length > 100 ? jsCode.substring(0, 100) + '...' : jsCode;
+      const lines = jsCode.split('\n');
+
+      logger.error(`Failed to minify inline script in ${filePath}`);
+      logger.error(`  Script #${scriptIndex + 1} (${lines.length} lines)`);
+      logger.error(`  Error: ${err.message}`);
+
+      if (err.line !== undefined) {
+        logger.error(`  Line ${err.line}, Column ${err.col || '?'}`);
+      }
+
+      logger.error(`  Preview: ${preview.replace(/\n/g, ' ')}`);
+
+      return fullMatch;
+    }
+  });
+
+  // Wait for all minification to complete
+  const minifiedScripts = await Promise.all(minifyPromises);
+
+  // Add all minified scripts to extracted array
+  minifiedScripts.forEach(script => extracted.push(script));
+
+  return { content, extracted };
+}
+
+// Helper: Restore inline scripts from placeholders
+function restoreInlineScripts(htmlContent, inlineScripts) {
+  let content = htmlContent;
+
+  inlineScripts.forEach((scriptContent, index) => {
+    content = content.replace(`__INLINE_SCRIPT_PLACEHOLDER_${index}__`, scriptContent);
+  });
+
+  return content;
+}
+
+// Helper: Extract IE conditional comments and replace with placeholders
+function extractConditionalComments(htmlContent) {
+  const extracted = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  const content = htmlContent.replace(conditionalRegex, (match, commentContent) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = commentContent
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      extracted.push(match.replace(commentContent, minifiedContent));
+    } catch (e) {
+      extracted.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${extracted.length - 1}__`;
+  });
+
+  return { content, extracted };
+}
+
+// Helper: Restore IE conditional comments from placeholders
+function restoreConditionalComments(htmlContent, conditionalComments) {
+  let content = htmlContent;
+
+  conditionalComments.forEach((commentContent, index) => {
+    content = content.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return content;
+}
+
 // Default Task (no watcher for minifyHtml as it runs after Jekyll build)
 module.exports = minifyHtmlTask;

package/dist/gulp/tasks/utils/BU/minifyHtml.js

@@ -0,0 +1,183 @@
+// Libraries
+const Manager = new (require('../../build.js'));
+const logger = Manager.logger('minifyHtml');
+const { src, dest, series } = require('gulp');
+const { minify } = require('html-minifier-terser');
+const through2 = require('through2');
+
+// Load package
+const package = Manager.getPackage('main');
+const project = Manager.getPackage('project');
+const config = Manager.getConfig('project');
+const rootPathPackage = Manager.getRootPath('main');
+const rootPathProject = Manager.getRootPath('project');
+
+// Glob
+const input = [
+  // Files to include
+  '_site/**/*.html',
+];
+const output = '_site';
+
+// Helper function to minify a single file's content
+async function minifyFileContent(htmlContent, options) {
+  // Extract and temporarily replace JSON-LD scripts
+  const jsonLdScripts = [];
+  const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+  htmlContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+    // Minify the JSON content
+    try {
+      const parsed = JSON.parse(jsonContent);
+      const minifiedJson = JSON.stringify(parsed);
+      jsonLdScripts.push(minifiedJson);
+    } catch (e) {
+      jsonLdScripts.push(jsonContent);
+    }
+    return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+  });
+
+  // Extract and temporarily replace IE conditional comments
+  const conditionalComments = [];
+  const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+  htmlContent = htmlContent.replace(conditionalRegex, (match, content) => {
+    // Minify the content inside the conditional comment
+    try {
+      const minifiedContent = content
+        .replace(/\s+/g, ' ')
+        .replace(/>\s+</g, '><')
+        .trim();
+      conditionalComments.push(match.replace(content, minifiedContent));
+    } catch (e) {
+      conditionalComments.push(match);
+    }
+    return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+  });
+
+  // Minify the HTML content
+  const minified = await minify(htmlContent, options);
+
+  // Restore the JSON-LD scripts and conditional comments
+  let finalHtml = minified;
+  jsonLdScripts.forEach((jsonContent, index) => {
+    const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+    finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${index}__`, scriptTag);
+  });
+
+  conditionalComments.forEach((commentContent, index) => {
+    finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${index}__`, commentContent);
+  });
+
+  return finalHtml;
+}
+
+// Helper function to process files in batches
+async function processBatch(batch, options, processed, total) {
+  return Promise.all(batch.map(async ({ file }) => {
+    try {
+      const htmlContent = file.contents.toString();
+      const finalHtml = await minifyFileContent(htmlContent, options);
+      file.contents = Buffer.from(finalHtml);
+      processed.count++;
+
+      // Log progress every 10 files or on last file
+      if (processed.count % 10 === 0 || processed.count === total) {
+        const percentage = ((processed.count / total) * 100).toFixed(1);
+        logger.log(`Progress: ${processed.count}/${total} files (${percentage}%)`);
+        Manager.logMemory(logger, `After ${processed.count} files`);
+      }
+
+      return file;
+    } catch (err) {
+      logger.error(`Error minifying ${file.path}: ${err.message}`);
+      return file;
+    }
+  }));
+}
+
+// Main task
+function minifyHtmlTask(complete) {
+  // Check if we should minify
+  const shouldMinify = Manager.isBuildMode() || process.env.UJ_MINIFY_HTML_FORCE === 'true';
+
+  if (!shouldMinify) {
+    logger.log('Skipping HTML minification (not in production mode and UJ_MINIFY_HTML_FORCE not set)');
+    return complete();
+  }
+
+  // Get concurrency limit from environment or use default
+  const CONCURRENCY_LIMIT = parseInt(process.env.UJ_MINIFY_CONCURRENCY || '10', 10);
+
+  // Log
+  logger.log('Starting...');
+  logger.log(`Concurrency limit: ${CONCURRENCY_LIMIT} files at a time`);
+  Manager.logMemory(logger, 'Start');
+
+  // Configure minify options
+  const options = {
+    collapseWhitespace: true,
+    removeComments: true,
+    removeAttributeQuotes: true,
+    removeRedundantAttributes: true,
+    removeScriptTypeAttributes: true,
+    removeStyleLinkTypeAttributes: true,
+    useShortDoctype: true,
+    removeEmptyAttributes: true,
+    removeOptionalTags: false,
+    minifyCSS: true,
+    minifyJS: true
+  };
+
+  // Collect files for batch processing
+  const fileQueue = [];
+  const processed = { count: 0 };
+
+  // Process HTML files
+  return src(input)
+    .pipe(through2.obj(function(file, _enc, callback) {
+      if (file.isBuffer()) {
+        fileQueue.push({ file });
+        callback();
+      } else {
+        callback(null, file);
+      }
+    }, async function(callback) {
+      // This function is called when all files have been queued
+      if (fileQueue.length === 0) {
+        logger.log('No HTML files to minify');
+        return callback();
+      }
+
+      const totalFiles = fileQueue.length;
+      logger.log(`Minifying ${totalFiles} HTML files...`);
+
+      try {
+        // Process files in batches
+        for (let i = 0; i < fileQueue.length; i += CONCURRENCY_LIMIT) {
+          const batch = fileQueue.slice(i, i + CONCURRENCY_LIMIT);
+          const processedFiles = await processBatch(batch, options, processed, totalFiles);
+
+          // Push processed files to the stream
+          processedFiles.forEach(file => this.push(file));
+        }
+
+        callback();
+      } catch (err) {
+        logger.error(`Batch processing error: ${err.message}`);
+        callback(err);
+      }
+    }))
+    .pipe(dest(output))
+    .on('finish', () => {
+      // Log
+      logger.log('Finished!');
+      Manager.logMemory(logger, 'End');
+
+      // Complete
+      complete();
+    });
+}
+
+// Default Task (no watcher for minifyHtml as it runs after Jekyll build)
+module.exports = minifyHtmlTask;

package/dist/gulp/tasks/utils/BU/minifyHtml.worker.js

@@ -0,0 +1,72 @@
+// Worker thread for HTML minification
+const { parentPort, workerData } = require('worker_threads');
+const { minify } = require('html-minifier-terser');
+
+// Listen for messages from parent
+parentPort.on('message', async (data) => {
+  const { htmlContent, options, index } = data;
+
+  try {
+    // Extract and temporarily replace JSON-LD scripts
+    const jsonLdScripts = [];
+    const jsonLdRegex = /<script[^>]*type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi;
+
+    let processedContent = htmlContent.replace(jsonLdRegex, (match, jsonContent) => {
+      // Minify the JSON content
+      try {
+        const parsed = JSON.parse(jsonContent);
+        const minifiedJson = JSON.stringify(parsed);
+        jsonLdScripts.push(minifiedJson);
+      } catch (e) {
+        jsonLdScripts.push(jsonContent);
+      }
+      return `__JSON_LD_PLACEHOLDER_${jsonLdScripts.length - 1}__`;
+    });
+
+    // Extract and temporarily replace IE conditional comments
+    const conditionalComments = [];
+    const conditionalRegex = /<!--\[if[^>]*\]>([\s\S]*?)<!\[endif\]-->/gi;
+
+    processedContent = processedContent.replace(conditionalRegex, (match, content) => {
+      // Minify the content inside the conditional comment
+      try {
+        const minifiedContent = content
+          .replace(/\s+/g, ' ')
+          .replace(/>\s+</g, '><')
+          .trim();
+        conditionalComments.push(match.replace(content, minifiedContent));
+      } catch (e) {
+        conditionalComments.push(match);
+      }
+      return `__CONDITIONAL_COMMENT_PLACEHOLDER_${conditionalComments.length - 1}__`;
+    });
+
+    // Minify the HTML content
+    const minified = await minify(processedContent, options);
+
+    // Restore the JSON-LD scripts and conditional comments
+    let finalHtml = minified;
+    jsonLdScripts.forEach((jsonContent, idx) => {
+      const scriptTag = `<script type=application/ld+json>${jsonContent}</script>`;
+      finalHtml = finalHtml.replace(`__JSON_LD_PLACEHOLDER_${idx}__`, scriptTag);
+    });
+
+    conditionalComments.forEach((commentContent, idx) => {
+      finalHtml = finalHtml.replace(`__CONDITIONAL_COMMENT_PLACEHOLDER_${idx}__`, commentContent);
+    });
+
+    // Send result back to parent
+    parentPort.postMessage({
+      success: true,
+      index,
+      result: finalHtml
+    });
+  } catch (err) {
+    // Send error back to parent
+    parentPort.postMessage({
+      success: false,
+      index,
+      error: err.message
+    });
+  }
+});

package/firebase-debug.log

@@ -54,3 +54,11 @@
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
 [debug] [2025-10-22T06:51:09.274Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
 [debug] [2025-10-22T06:51:09.274Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.642Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)
+[debug] [2025-10-22T08:40:01.644Z] > command requires scopes: ["email","openid","https://www.googleapis.com/auth/cloudplatformprojects.readonly","https://www.googleapis.com/auth/firebase","https://www.googleapis.com/auth/cloud-platform"]
+[debug] [2025-10-22T08:40:01.644Z] > authorizing via signed-in user (ian.wiedenman@gmail.com)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-jekyll-manager",
-  "version": "0.0.93",
+  "version": "0.0.94",
   "description": "Ultimate Jekyll dependency manager",
   "main": "dist/index.js",
   "exports": {
@@ -62,6 +62,7 @@
     "@babel/core": "^7.28.4",
     "@babel/preset-env": "^7.28.3",
     "@fullhuman/postcss-purgecss": "^7.0.2",
+    "@minify-html/node": "^0.16.4",
     "@octokit/rest": "^22.0.0",
     "@popperjs/core": "^2.11.8",
     "@prettier/plugin-xml": "^3.4.2",