uglify-js-minify-css-allfiles 2.2.4 → 2.3.1

package/dist/module.js

@@ -2,106 +2,149 @@
  * uglify-js and minify-css for all files
  * Released under the terms of MIT license
  * Copyright (C) 2024 yeongmin
+ * @module module
  */
 
 import { promises as fs } from 'fs';
-import path from 'path';
+import crypto from 'crypto';
 import Logger from './modules/logger.js';
-import { getAllFiles, writeFile } from './modules/fileHandler.js';
+import { getAllFiles, writeFile, shouldVersionFile } from './modules/fileHandler.js';
+import HashManager from './modules/hashManager.js';
 import { minifyJS, minifyCSS } from './modules/minifier.js';
-import { createRequire } from 'module';
-import { fileURLToPath, pathToFileURL } from 'url';
-
-const require = createRequire(import.meta.url);
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+import { DEFAULT_IMAGE_EXTENSIONS, IMAGE_PATTERNS } from './modules/imageUtils.js';
+import { resolveImagePath, resolveModulePath, makeRelativePath, containsFolder, getExtension, resolvePath } from './modules/pathResolver.js';
 
 /**
- * Resolves the path of a module.
- * @param {string} moduleName - The name of the module to resolve.
- * @returns {string} The resolved module path as a URL.
+ * Processes image references in files and adds/updates version hashes for cache busting.
+ * Handles both JavaScript and CSS files differently:
+ * - For JS files: Generates a random hash
+ * - For CSS files: Generates a content-based hash
+ *
+ * @async
+ * @param {RegExp} pattern - Regular expression pattern to match image references
+ * @param {string} content - Content of the file being processed
+ * @param {string} fileExt - File extension (e.g., '.js', '.css')
+ * @param {string} filePath - Absolute path to the file being processed
+ * @param {Logger} logger - Logger instance for tracking changes
+ * @param {HashManager} hashManager - Manages content-based hashing for images
+ * @param {string[]} targetExtensions - List of image extensions to process (e.g., ['.png', '.jpg'])
+ * @returns {Promise<{content: string, modified: boolean}>} Modified content and whether changes were made
  */
-function resolveModulePath(moduleName) {
-  const modulePath = require.resolve(moduleName, { paths: [__dirname] });
-  return pathToFileURL(modulePath).href;
-}
+async function processPattern(pattern, content, fileExt, filePath, logger, hashManager, targetExtensions) {
+  const promises = [];
+  let newContent = content;
+  let modified = false;
 
-/**
- * @typedef {Object} FileHandlerOptions
- * @property {BabelOptions} [babelOptions] - Babel transformation options.
- * @property {JSMinifyOptions} [jsMinifyOptions] - JavaScript minification options.
- * @property {CSSMinifyOptions} [cssMinifyOptions] - CSS minification options.
- */
+  if (fileExt === '.js') {
+    const newHash = crypto.randomBytes(16).toString('hex').substring(0, 8);
 
-/**
- * @callback FileHandler
- * @param {string} filePath - The path of the file to process.
- * @param {string} content - The content of the file.
- * @param {Logger} logger - The logger instance.
- * @param {FileHandlerOptions} options - Options for processing.
- * @returns {Promise<void>}
- */
+    newContent = content.replace(pattern, (match, imagePath, ext, queryString) => {
+      if (imagePath.startsWith('data:') || imagePath.startsWith('http://') || imagePath.startsWith('https://')) {
+        return match;
+      }
+      modified = true;
+      logger?.info('Updated JS image version', {
+        file: filePath,
+        image: imagePath + ext,
+        newHash,
+      });
+      return `${imagePath}${ext}?v=${newHash}${queryString}`;
+    });
+    return { content: newContent, modified };
+  }
 
-/**
- * Object containing handlers for different file types.
- * @type {Object.<string, FileHandler>}
- */
-const FILE_HANDLERS = {
-  '.js': async (filePath, content, logger, options) => {
-    try {
-      let transformed = content;
-      if (options.babelOptions) {
-        const babelCoreUrl = resolveModulePath('@babel/core');
-        const { transformSync } = await import(babelCoreUrl);
-        transformed = transformSync(content, options.babelOptions).code;
+  if (fileExt === '.css') {
+    newContent = content.replace(pattern, (match, imagePath, _ext, queryString) => {
+      if (imagePath.startsWith('data:') || imagePath.startsWith('http://') || imagePath.startsWith('https://')) {
+        return match;
       }
-      const result = minifyJS(transformed, options.jsMinifyOptions);
-      await writeFile(filePath, result, logger);
-    } catch (error) {
-      await logger?.error('JavaScript minification failed', { filePath, error: error.message });
-    }
-  },
-  '.css': async (filePath, content, logger, options) => {
-    try {
-      const output = await minifyCSS(content, options.cssMinifyOptions);
-      if (0 < output.warnings.length) {
-        await logger?.warn('CSS minification warnings', { filePath, warnings: output.warnings });
+
+      const absoluteImagePath = resolveImagePath(imagePath, filePath);
+      if (!absoluteImagePath || !shouldVersionFile(absoluteImagePath, targetExtensions)) {
+        return match;
+      }
+
+      const marker = `__HASH_MARKER_${promises.length}__`;
+      promises.push({ marker, imagePath, absoluteImagePath });
+      return match.replace(imagePath + (queryString || ''), `${imagePath}?v=${marker}`);
+    });
+
+    if (promises.length > 0) {
+      for (const { marker, imagePath, absoluteImagePath } of promises) {
+        const { hash, changed } = await hashManager.generateHash(absoluteImagePath);
+
+        if (!hash) {
+          newContent = newContent.replace(`${imagePath}?v=${marker}`, imagePath);
+          // 'Failed to generate hash, keeping original URL : ' + filePath;
+          continue;
+        }
+
+        if (changed) {
+          modified = true;
+          await logger?.info('Updated CSS image version', {
+            file: filePath,
+            image: imagePath,
+            oldHash: hashManager.getPreviousHash(absoluteImagePath),
+            newHash: hash,
+          });
+        }
+
+        newContent = newContent.replace(`?v=${marker}`, `?v=${hash}`);
       }
-      await writeFile(filePath, output.styles, logger);
-    } catch (error) {
-      await logger?.error('CSS minification failed', { filePath, error: error.message });
     }
-  },
-};
+
+    await Promise.all(promises.filter((p) => p instanceof Promise));
+  }
+
+  return { content: newContent, modified };
+}
 
 /**
- * Processes a single file based on its extension.
+ * Updates image references in a file with version query strings.
  * @async
- * @param {string} filePath - The path of the file to process.
- * @param {Logger} logger - The logger instance.
- * @param {FileHandlerOptions} options - Options for processing.
+ * @param {string} filePath - Path to the file to process.
+ * @param {Object} versioningOptions - Options for versioning.
+ * @param {string[]} [versioningOptions.extensions] - List of file extensions to version.
+ * @param {Logger} logger - Logger instance.
+ * @param {HashManager} hashManager - Hash manager instance.
  * @returns {Promise<void>}
  */
-async function processFile(filePath, logger, options) {
+async function updateImageReferences(filePath, versioningOptions, logger, hashManager) {
+  const { extensions } = versioningOptions;
+  const targetExtensions =
+    extensions || DEFAULT_IMAGE_EXTENSIONS.map((ext) => (ext === 'jpe?g' ? ['.jpg', '.jpeg'] : ['.' + ext.replace('?', '')])).flat();
+
+  const fileExt = getExtension(filePath);
+  const patterns = IMAGE_PATTERNS[fileExt.substring(1)] || [];
+
   try {
-    const fileContent = await fs.readFile(filePath, 'utf-8');
-    const fileExtension = path.extname(filePath).toLowerCase();
-    const handler = FILE_HANDLERS[fileExtension];
+    let content = await fs.readFile(filePath, 'utf-8');
+    let modified = false;
 
-    if (handler) {
-      await handler(filePath, fileContent, logger, options);
-    } else {
-      await logger?.info(`Unsupported file type, skipping: ${filePath}`);
+    for (const pattern of patterns) {
+      const result = await processPattern(pattern, content, fileExt, filePath, logger, hashManager, targetExtensions);
+      content = result.content;
+      modified = modified || result.modified;
+    }
+
+    if (modified) {
+      await fs.writeFile(filePath, content, 'utf-8');
+      await logger?.info('Updated file with versioned image references', {
+        file: filePath,
+      });
     }
   } catch (error) {
-    await logger?.error('Error processing file', { filePath, error: error.message });
+    await logger?.error('Failed to process file', {
+      file: filePath,
+      error: error.message,
+    });
   }
 }
 
 /**
  * Resolves Babel options based on the provided configuration.
  * @param {boolean|BabelOptions} useBabel - The Babel options object or boolean.
- * @returns {Promise<BabelOptions|null>} A promise that resolves to the Babel options or null if no valid options are provided.
+ * @returns {Promise<BabelOptions|null>} - A promise that resolves to the Babel options or null if disabled.
  */
 async function resolveBabelOptions(useBabel) {
   if (!useBabel) return null;
@@ -119,6 +162,48 @@ async function resolveBabelOptions(useBabel) {
   }
 }
 
+/**
+ * Processes a single file based on its extension.
+ * @async
+ * @param {string} filePath - The path of the file to process.
+ * @param {Logger} logger - The logger instance.
+ * @param {Object} options - Processing options.
+ * @param {BabelOptions} [options.babelOptions] - Babel transformation options.
+ * @param {Object} [options.jsMinifyOptions] - JavaScript minification options.
+ * @param {Object} [options.cssMinifyOptions] - CSS minification options.
+ * @returns {Promise<void>}
+ */
+async function processFile(filePath, logger, options) {
+  try {
+    const fileContent = await fs.readFile(filePath, 'utf-8');
+    const fileExtension = getExtension(filePath);
+
+    let result;
+    if (fileExtension === '.js') {
+      let transformed = fileContent;
+      if (options.babelOptions) {
+        const babelCoreUrl = resolveModulePath('@babel/core');
+        const { transformSync } = await import(babelCoreUrl);
+        transformed = transformSync(fileContent, options.babelOptions).code;
+      }
+      result = minifyJS(transformed, options.jsMinifyOptions);
+    } else if (fileExtension === '.css') {
+      const output = await minifyCSS(fileContent, options.cssMinifyOptions);
+      if (output.warnings.length > 0) {
+        await logger?.warn('CSS minification warnings', { filePath, warnings: output.warnings });
+      }
+      result = output.styles;
+    } else {
+      // `Unsupported file type, skipping: ${filePath}`;
+      return;
+    }
+
+    await writeFile(filePath, result, logger);
+  } catch (error) {
+    await logger?.error('Error processing file', { filePath, error: error.message });
+  }
+}
+
 /**
  * Options for Babel configuration.
  * @typedef {Object} BabelOptions
@@ -167,39 +252,44 @@ async function resolveBabelOptions(useBabel) {
  * Options for minification configuration.
  * @typedef {Object} MinifyOptions
  * @property {string} [excludeFolder=''] - Folder to exclude from minification.
- * @property {boolean|BabelOptions} [useBabel=false] - Whether to use Babel for transformation, and the options for Babel if used.
- * @property {boolean|LogOptions} [useLog=true] - Whether to use logging, and the options for logging if used.
+ * @property {boolean|BabelOptions} [useBabel=false] - Whether to use Babel for transformation.
+ * @property {boolean|LogOptions} [useLog=true] - Whether to use logging.
  * @property {JSMinifyOptions} [jsMinifyOptions={}] - Options for JavaScript minification.
  * @property {CSSMinifyOptions} [cssMinifyOptions={}] - Options for CSS minification.
+ * @property {string[]|null} [useVersioning=null] - Options for file versioning.
  */
 
 /**
- * Minifies all JavaScript and CSS files in the specified directory and its subdirectories.
- *
- * @param {string} contentPath - The path to the directory containing the files to be minified.
- * @param {MinifyOptions} [options={}] - Options for minification, Babel, and logging.
- * @returns {Promise<void>} A promise that resolves when all files have been processed.
+ * Main function to minify all files and handle versioning.
+ * @async
+ * @param {string} contentPath - The path to process files from.
+ * @param {MinifyOptions} [options={}] - Configuration options.
+ * @returns {Promise<void>} - A promise that resolves when all files have been processed.
  * @throws {Error} If there's an issue reading or writing files.
  */
 export default async function minifyAll(contentPath, options = {}) {
-  const {
-    excludeFolder = '',
-    useBabel = false,
-    useLog = true,
-    jsMinifyOptions = {},
-    cssMinifyOptions = {},
-  } = options;
+  const { excludeFolder = '', useBabel = false, useLog = true, jsMinifyOptions = {}, cssMinifyOptions = {}, useVersioning = null } = options;
 
   let logger = null;
   if (useLog) {
     const logOptions = typeof useLog === 'object' ? useLog : {};
     logger = new Logger(logOptions);
     await logger.initialize();
-    await logger.info('Starting minification process', { contentPath, excludeFolder, useBabel });
+    await logger.info('Starting minification process', {
+      contentPath,
+      excludeFolder,
+      useBabel,
+      useVersioning: !!useVersioning,
+    });
   }
 
-  const rootDir = path.resolve(contentPath || '');
+  const rootDir = resolvePath(contentPath || '');
   const babelOptions = await resolveBabelOptions(useBabel);
+  const hashManager = useVersioning ? new HashManager(rootDir) : null;
+
+  if (hashManager) {
+    await hashManager.initialize();
+  }
 
   const processOptions = {
     babelOptions,
@@ -209,17 +299,19 @@ export default async function minifyAll(contentPath, options = {}) {
 
   try {
     await getAllFiles(rootDir, async (filePath) => {
-      const relativePath = path.relative(rootDir, filePath);
-      if (
-        excludeFolder &&
-        (relativePath.startsWith(excludeFolder) ||
-          relativePath.includes(path.sep + excludeFolder + path.sep))
-      ) {
+      const relativePath = makeRelativePath(filePath, rootDir);
+      if (excludeFolder && containsFolder(relativePath, excludeFolder)) {
         await logger?.debug('Skipping excluded file', { filePath });
         return;
       }
 
       await processFile(filePath, logger, processOptions);
+
+      // Apply versioning after successful processing if enabled
+      if (useVersioning && hashManager) {
+        await updateImageReferences(filePath, useVersioning, logger, hashManager);
+      }
+
       logger?.incrementProcessedFiles(filePath);
     });
   } catch (error) {

package/dist/modules/fileHandler.js

@@ -4,20 +4,21 @@
  */
 
 import { promises as fs } from 'fs';
-import path from 'path';
+import { joinPaths, getExtension } from './pathResolver.js';
 
 /**
  * Recursively gets all files in a directory and its subdirectories.
- *
  * @async
- * @param {string} dirPath - The path to the directory to search.
- * @param {Function} callback - The callback function to execute for each file.
+ * @param {string} dirPath - The path to the directory to search
+ * @param {Function} callback - Callback function for each file
+ * @param {string} callback.filePath - Full path to the file
+ * @param {fs.Stats} callback.fileStat - File statistics
  * @returns {Promise<void>}
  */
 export async function getAllFiles(dirPath, callback) {
   const files = await fs.readdir(dirPath);
   for (const file of files) {
-    const filePath = path.join(dirPath, file);
+    const filePath = joinPaths(dirPath, file);
     const fileStat = await fs.stat(filePath);
     if (fileStat.isFile()) {
       await callback(filePath, fileStat);
@@ -28,12 +29,11 @@ export async function getAllFiles(dirPath, callback) {
 }
 
 /**
- * Writes content to a file.
- *
+ * Writes content to a file with logging
  * @async
- * @param {string} filePath - The path of the file to write.
- * @param {string} content - The content to write to the file.
- * @param {Object} logger - The logger object for logging operations.
+ * @param {string} filePath - Path to write the file
+ * @param {string} content - Content to write
+ * @param {Logger} [logger] - Logger instance for operation logging
  * @returns {Promise<void>}
  */
 export async function writeFile(filePath, content, logger) {
@@ -49,3 +49,14 @@ export async function writeFile(filePath, content, logger) {
     await logger?.error(`Write failed: ${error.message}`, { filePath });
   }
 }
+
+/**
+ * Checks if a file should be versioned based on its extension
+ * @param {string} filePath - Path to the file
+ * @param {string[]} extensions - List of extensions to match against
+ * @returns {boolean} Whether the file should be versioned
+ */
+export function shouldVersionFile(filePath, extensions) {
+  const ext = getExtension(filePath);
+  return extensions.includes(ext);
+}

package/dist/modules/hashManager.js

@@ -0,0 +1,114 @@
+/**
+ * Hash manager module for tracking file changes
+ * @module hashManager
+ */
+
+import { promises as fs } from 'fs';
+import crypto from 'crypto';
+import { joinPaths } from './pathResolver.js';
+
+const HASH_FILE = '.image-hashes.json';
+
+/**
+ * Hash manager class for tracking file changes and maintaining version history
+ * @class
+ */
+export default class HashManager {
+  /**
+   * Creates a new HashManager instance
+   * @param {string} rootDir - Root directory for hash file storage
+   */
+  constructor(rootDir) {
+    this.hashFile = joinPaths(rootDir, HASH_FILE);
+    this.hashes = new Map();
+    this.initialized = false;
+  }
+
+  /**
+   * Initializes the hash manager by loading existing hashes from file
+   * @async
+   * @returns {Promise<void>}
+   */
+  async initialize() {
+    if (this.initialized) return;
+
+    try {
+      const content = await fs.readFile(this.hashFile, 'utf-8');
+      const savedHashes = JSON.parse(content);
+      Object.entries(savedHashes).forEach(([key, value]) => {
+        this.hashes.set(key, value);
+      });
+    } catch (error) {
+      await this.save();
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Saves current hashes to the hash file
+   * @async
+   * @returns {Promise<void>}
+   */
+  async save() {
+    const hashObject = Object.fromEntries(this.hashes);
+    await fs.writeFile(this.hashFile, JSON.stringify(hashObject, null, 2));
+  }
+
+  /**
+   * Gets the previous hash for a file
+   * @param {string} filePath - Path to the file
+   * @returns {string|null} Previous hash value or null if not found
+   */
+  getPreviousHash(filePath) {
+    return this.hashes.get(filePath);
+  }
+
+  /**
+   * Updates the hash for a file and saves to disk
+   * @async
+   * @param {string} filePath - Path to the file
+   * @param {string} hash - New hash value
+   * @returns {Promise<void>}
+   */
+  async updateHash(filePath, hash) {
+    this.hashes.set(filePath, hash);
+    await this.save();
+  }
+
+  /**
+   * Generates a hash for a file and checks if it changed
+   * @async
+   * @param {string} filePath - Path to the file
+   * @returns {Promise<{hash: string|null, changed: boolean}>} Hash information
+   */
+  async generateHash(filePath) {
+    try {
+      // Check file existence
+      try {
+        await fs.access(filePath);
+      } catch (error) {
+        // `File not found: ${filePath}`;
+        return { hash: null, changed: false };
+      }
+
+      const content = await fs.readFile(filePath);
+      const newHash = crypto.createHash('md5').update(content).digest('hex').substring(0, 8);
+
+      const previousHash = this.getPreviousHash(filePath);
+      const changed = previousHash !== newHash;
+
+      if (changed) {
+        await this.updateHash(filePath, newHash);
+      }
+
+      return {
+        hash: newHash,
+        changed: changed || !previousHash,
+      };
+    } catch (error) {
+      console.error(`Error generating hash for ${filePath}:`, error);
+      return { hash: null, changed: false };
+    }
+  }
+}

package/dist/modules/imageUtils.js

@@ -0,0 +1,63 @@
+/**
+ * Image utilities module for handling image paths and patterns
+ * @module imageUtils
+ */
+
+// All supported image formats
+export const DEFAULT_IMAGE_EXTENSIONS = ['png', 'jpe?g', 'gif', 'svg', 'webp', 'avif', 'jxl', 'heic', 'heif', 'bmp', 'tiff?'];
+
+const IMAGE_EXT_PATTERN = DEFAULT_IMAGE_EXTENSIONS.join('|');
+
+export const IMAGE_PATTERNS = {
+  css: [
+    // url() pattern that handles query parameters separately
+    new RegExp(`url\\(['"]?([^'"()\\s?#]+\\.(${IMAGE_EXT_PATTERN}))([?][^'"()\\s]*)?['"]?\\)`, 'gi'),
+
+    // image-set() pattern with separate query parameter capture
+    new RegExp(
+      `image-set\\(\\s*(?:['"]([^'"?#]+\\.(${IMAGE_EXT_PATTERN}))([?][^'"()\\s]*)?['"]\\s*(?:type\\(['"]image/[^'"]+['"]\\))?\\s*,?\\s*)+\\)`,
+      'gi',
+    ),
+
+    // Additional pattern for complex background(CSS) declarations
+    new RegExp(`(?:^|\\s|,)url\\(['"]?([^'"()\\s?#]+\\.(${IMAGE_EXT_PATTERN}))([?][^'"()\\s]*)?['"]?\\)`, 'gi'),
+  ],
+  js: [
+    // Basic extension-based pattern for all quotes
+    new RegExp(`(['"\`])([^'"\`]*?\\.(?:${IMAGE_EXT_PATTERN}))(['"\`])`, 'gi'),
+  ],
+};
+
+/**
+ * Parse URL and query parameters
+ * @param {string} url - URL to parse
+ * @returns {{path: string, params: URLSearchParams}} Parsed URL parts
+ */
+export function parseURL(url) {
+  const [path, query] = url.split('?');
+  return {
+    path,
+    params: new URLSearchParams(query || ''),
+  };
+}
+
+/**
+ * Updates image reference with version query string
+ * @param {string} match - Full matched string
+ * @param {string} imagePath - Image path without query parameters
+ * @param {string} existingQuery - Existing query string (if any)
+ * @param {string} version - Version string to append
+ * @returns {string} Updated reference with version
+ */
+export function updateImageReference(match, imagePath, existingQuery, version) {
+  // Skip data URIs
+  if (imagePath.startsWith('data:')) {
+    return match;
+  }
+
+  // Add version parameter, replacing any existing version
+  const versionedPath = `${imagePath}?v=${version}`;
+
+  // Replace while preserving the original structure
+  return match.replace(imagePath + (existingQuery || ''), versionedPath);
+}

package/dist/modules/logger.js

@@ -1,5 +1,5 @@
 import fs from 'fs/promises';
-import path from 'path';
+import { joinPaths } from './pathResolver.js';
 
 class Logger {
   static LOG_LEVELS = {
@@ -59,9 +59,7 @@ class Logger {
       this.logLevel = Logger.LOG_LEVELS[normalizedLevel];
       console.log(`Log level set to "${normalizedLevel}"`);
     } else {
-      console.warn(
-        `Invalid log level "${level}". Using default level "${Logger.DEFAULT_LOG_LEVEL}".`,
-      );
+      console.warn(`Invalid log level "${level}". Using default level "${Logger.DEFAULT_LOG_LEVEL}".`);
       this.logLevel = Logger.LOG_LEVELS[Logger.DEFAULT_LOG_LEVEL];
     }
   }
@@ -131,7 +129,7 @@ class Logger {
   }
 
   getLogFilePath() {
-    return path.join(this.logDir, `log-${this.currentDate}.log`);
+    return joinPaths(this.logDir, `log-${this.currentDate}.log`);
   }
 
   getCurrentDate() {
@@ -152,7 +150,7 @@ class Logger {
         const files = await fs.readdir(this.logDir);
         const now = new Date();
         for (const file of files) {
-          const filePath = path.join(this.logDir, file);
+          const filePath = joinPaths(this.logDir, file);
           const stats = await fs.stat(filePath);
           const diffDays = (now - stats.mtime) / (1000 * 60 * 60 * 24);
           if (diffDays > this.retentionDays) {

package/dist/modules/minifier.js

@@ -8,10 +8,9 @@ import CleanCSS from 'clean-css';
 
 /**
  * Minifies JavaScript content.
- *
- * @param {string} content - The JavaScript content to minify.
- * @param {Object} options - Options for JavaScript minification.
- * @returns {string} The minified JavaScript content.
+ * @param {string} content - JavaScript content to minify.
+ * @param {Object} [options={}] - UglifyJS options.
+ * @returns {string} Minified JavaScript code.
  */
 export function minifyJS(content, options = {}) {
   const defaultOptions = {
@@ -30,11 +29,10 @@ export function minifyJS(content, options = {}) {
 
 /**
  * Minifies CSS content.
- *
  * @async
- * @param {string} content - The CSS content to minify.
- * @param {Object} options - Options for CSS minification.
- * @returns {Promise<Object>} A promise that resolves to the minification result.
+ * @param {string} content - CSS content to minify.
+ * @param {Object} [options={}] - Clean-CSS options.
+ * @returns {Promise<{styles: string, warnings: string[]}>} Minified CSS and warnings.
  */
 export function minifyCSS(content, options = {}) {
   const defaultOptions = {