@zulaica/site-bundler 0.7.0 → 0.8.0

package/lib/helpers/constants.mjs

@@ -1,92 +1,93 @@
 /* node:coverage disable */
 export const EMOJI = Object.freeze({
-  artistPalette: '\u{1f3a8}',
-  barChart: '\u{1f4ca}',
-  cardIndexDividers: '\u{1f5c2}',
-  constructionWorker: '\u{1f477}',
-  fileCabinet: '\u{1f5c4} ',
-  fileFolder: '\u{1f4c1}',
-  noEntry: '\u{26D4}',
-  package: '\u{1f4e6}',
-  wastebasket: '\u{1f5d1} '
+  artistPalette: "\u{1f3a8}",
+  barChart: "\u{1f4ca}",
+  cardIndexDividers: "\u{1f5c2}",
+  constructionWorker: "\u{1f477}",
+  fileCabinet: "\u{1f5c4} ",
+  fileFolder: "\u{1f4c1}",
+  noEntry: "\u{26D4}",
+  package: "\u{1f4e6}",
+  wastebasket: "\u{1f5d1} ",
 });
 
 export const EXCLUSIONS = Object.freeze([
-  'index.html',
-  'script.hash.js',
-  'scripts',
-  'style.hash.css',
-  'styles'
+  "index.html",
+  "script.hash.js",
+  "scripts",
+  "style.hash.css",
+  "styles",
 ]);
 
 export const OPTIONS = Object.freeze({
   babel: {
     presets: [
       [
-        '@babel/preset-env',
+        "@babel/preset-env",
         {
-          targets: 'defaults',
-          modules: false
-        }
-      ]
+          targets: "defaults",
+          modules: false,
+        },
+      ],
     ],
     babelrc: false,
     comments: false,
     configFile: false,
-    minified: true
+    minified: true,
   },
   rollup: {
     onwarn(warning, warn) {
-      if (warning.code === 'EMPTY_BUNDLE') return;
+      if (warning.code === "EMPTY_BUNDLE") return;
       warn(warning);
-    }
+    },
   },
   postcss: {
     cssnano: {
       preset: [
-        'advanced',
+        "advanced",
         {
           minifyFontValues: false,
           normalizeUrl: false,
           normalizeString: {
-            preferredQuote: 'single'
-          }
-        }
-      ]
+            preferredQuote: "single",
+          },
+        },
+      ],
     },
     url: [
       {
-        filter: '**/*.woff2',
-        url: 'rebase'
+        filter: "**/*.woff2",
+        url: "rebase",
       },
       {
-        filter: '**/*.woff',
-        url: 'rebase'
+        filter: "**/*.woff",
+        url: "rebase",
       },
       {
-        filter: '**/*.ttf',
-        url: 'rebase'
+        filter: "**/*.ttf",
+        url: "rebase",
       },
       {
-        filter: '**/*.webp',
-        url: (asset) => asset.relativePath
+        filter: "**/*.webp",
+        url: (asset) => asset.relativePath,
       },
       {
-        filter: '**/*.jpg',
-        url: (asset) => asset.relativePath
-      }
-    ]
+        filter: "**/*.jpg",
+        url: (asset) => asset.relativePath,
+      },
+    ],
   },
   posthtml: {
     htmlnano: {
       collapseBooleanAttributes: {
-        amphtml: false
+        amphtml: false,
       },
-      collapseWhitespace: 'aggressive',
+      collapseWhitespace: "aggressive",
+      minifyCss: false,
       minifyJs: false,
-      removeComments: 'all',
-      removeEmptyAttributes: false
-    }
-  }
+      removeComments: "all",
+      removeEmptyAttributes: false,
+    },
+  },
 });
 /* node:coverage enable */

package/lib/helpers/logger.mjs

@@ -1,17 +1,18 @@
-import { exit, stderr, stdout } from 'node:process';
-import { clearLine, cursorTo } from 'node:readline';
-import { EMOJI } from './constants.mjs';
+import { exit, stderr, stdout } from "node:process";
+import { clearLine, cursorTo } from "node:readline";
+import { EMOJI } from "./constants.mjs";
 
 export default class Logger {
   static error = (error) => {
     stderr.write(`${EMOJI.noEntry} An error has occurred\n`);
     stderr.write(`${error.toString()}\n\n`);
-    stderr.write('', () => exit(1));
+    stderr.write("", () => exit(1));
   };
 
   static message = (message, update = false) => {
-    if (process.env.NODE_ENV !== 'test') {
+    if (process.env.NODE_ENV !== "test") {
       if (update) {
+        message += "\n";
         cursorTo(stdout, 0);
         clearLine(stdout, 0);
       }

package/lib/helpers/tests.mjs

@@ -1,12 +1,12 @@
-import { mkdir, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach } from 'node:test';
+import { mkdir, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach } from "node:test";
 
 const baseDir = join(tmpdir(), `site-bundler-test-${Date.now()}`);
 
-export const inputDir = join(baseDir, 'input');
-export const outputDir = join(baseDir, 'output');
+export const inputDir = join(baseDir, "input");
+export const outputDir = join(baseDir, "output");
 
 export const inputCSS = `
 /**
@@ -25,7 +25,7 @@ h1 {
 `;
 
 export const processedCSS =
-  'body{font-family:Arial,sans-serif;margin:0;padding:20px}h1{color:#333}';
+  "body{font-family:Arial,sans-serif;margin:0;padding:20px}h1{color:#333}";
 
 export const inputHTML = `
 <!DOCTYPE html>
@@ -33,7 +33,16 @@ export const inputHTML = `
   <head>
     <!-- This is a comment -->
     <meta charset="utf-8" />
+    <style>
+      body {
+        margin: 0;
+        padding: 20px;
+      }
+    </style>
     <link rel="stylesheet" href="style.hash.css" />
+    <script>
+      document.documentElement.classList.add("js");
+    </script>
     <script src="script.hash.js"></script>
   </head>
   <body>
@@ -66,7 +75,7 @@ export const inputHTML = `
 `;
 
 export const processedHTML =
-  '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><link rel="stylesheet" href="style.hash.css"><script src="script.hash.js"></script></head><body><header><h1>Test Site</h1><nav><ul><li><a href="#home">Home</a></li><li><a href="#about">About</a></li></ul></nav></header><main><section><article><h2>Article Title</h2><p>Article content goes here.</p><p aria-hidden="true">This is hidden.</p></article></section><aside><input type="text" disabled placeholder="Enter text"></aside></main><footer><p>&copy; Year</p></footer></body></html>';
+  '<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><style>body{margin:0;padding:20px}</style><link rel="stylesheet" href="style.hash.css"><script>document.documentElement.classList.add("js");</script><script src="script.hash.js"></script></head><body><header><h1>Test Site</h1><nav><ul><li><a href="#home">Home</a></li><li><a href="#about">About</a></li></ul></nav></header><main><section><article><h2>Article Title</h2><p>Article content goes here.</p><p aria-hidden="true">This is hidden.</p></article></section><aside><input type="text" disabled placeholder="Enter text"></aside></main><footer><p>© Year</p></footer></body></html>';
 
 export const inputJS = `
 // This is a comment

package/lib/index.mjs

@@ -1,24 +1,24 @@
 #!/usr/bin/env node
 
-import { program } from 'commander';
-import { access, readFile } from 'node:fs/promises';
-import { EMOJI } from './helpers/constants.mjs';
-import Logger from './helpers/logger.mjs';
+import { program } from "commander";
+import { access, readFile } from "node:fs/promises";
+import { EMOJI } from "./helpers/constants.mjs";
+import Logger from "./helpers/logger.mjs";
 import {
   copyAssets,
   preflight,
   processCSS,
   processHTML,
-  processJS
-} from './modules/index.mjs';
+  processJS,
+} from "./modules/index.mjs";
 
 const { version } = JSON.parse(
-  await readFile(new URL('../package.json', import.meta.url))
+  await readFile(new URL("../package.json", import.meta.url)),
 );
 program
   .version(version)
-  .requiredOption('-i, --input-dir <input>', 'The input directory')
-  .requiredOption('-o, --output-dir <output>', 'The output directory')
+  .requiredOption("-i, --input-dir <input>", "The input directory")
+  .requiredOption("-o, --output-dir <output>", "The output directory")
   .parse();
 const opts = program.opts();
 

package/lib/index.test.mjs

@@ -1,89 +1,89 @@
-import assert from 'node:assert/strict';
-import { execFile } from 'node:child_process';
-import { readdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { promisify } from 'node:util';
-import { EMOJI } from './helpers/constants.mjs';
+import assert from "node:assert/strict";
+import { execFile } from "node:child_process";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { promisify } from "node:util";
+import { EMOJI } from "./helpers/constants.mjs";
 import {
   inputCSS,
   inputDir,
   inputHTML,
   inputJS,
   outputDir,
-  setUpTestHooks
-} from './helpers/tests.mjs';
+  setUpTestHooks,
+} from "./helpers/tests.mjs";
 
 const execFileAsync = promisify(execFile);
 const { version } = JSON.parse(
-  await readFile(new URL('../package.json', import.meta.url), 'utf8')
+  await readFile(new URL("../package.json", import.meta.url), "utf8"),
 );
 
 describe(`${EMOJI.package} CLI Integration`, () => {
   setUpTestHooks();
 
-  it('should display version', async () => {
-    const { stdout } = await execFileAsync('node', [
-      join(process.cwd(), 'lib', 'index.mjs'),
-      '--version'
+  it("should display version", async () => {
+    const { stdout } = await execFileAsync("node", [
+      join(process.cwd(), "lib", "index.mjs"),
+      "--version",
     ]);
 
     assert.ok(stdout.includes(version));
   });
 
-  it('should process complete site', async () => {
-    await writeFile(join(inputDir, 'index.html'), inputHTML);
-    await writeFile(join(inputDir, 'style.hash.css'), inputCSS);
-    await writeFile(join(inputDir, 'script.hash.js'), inputJS);
-    await writeFile(join(inputDir, 'favicon.ico'), '');
+  it("should process complete site", async () => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
+    await writeFile(join(inputDir, "favicon.ico"), "");
 
     await assert.doesNotReject(() =>
-      execFileAsync('node', [
-        join(process.cwd(), 'lib', 'index.mjs'),
-        '-i',
+      execFileAsync("node", [
+        join(process.cwd(), "lib", "index.mjs"),
+        "-i",
         inputDir,
-        '-o',
-        outputDir
-      ])
+        "-o",
+        outputDir,
+      ]),
     );
 
     const outputFiles = await readdir(outputDir);
 
     assert.deepEqual(outputFiles.sort(), [
-      'favicon.ico',
-      'index.html',
-      'script.hash.js',
-      'style.hash.css'
+      "favicon.ico",
+      "index.html",
+      "script.hash.js",
+      "style.hash.css",
     ]);
   });
 
-  it('should handle non-existent input directory', async () => {
-    const nonExistentDir = join(inputDir, 'non-existent');
+  it("should handle non-existent input directory", async () => {
+    const nonExistentDir = join(inputDir, "non-existent");
 
     await assert.rejects(
       () =>
-        execFileAsync('node', [
-          join(process.cwd(), 'lib', 'index.mjs'),
-          '-i',
+        execFileAsync("node", [
+          join(process.cwd(), "lib", "index.mjs"),
+          "-i",
           nonExistentDir,
-          '-o',
-          outputDir
+          "-o",
+          outputDir,
         ]),
-      /Input directory does not exist/
+      /Input directory does not exist/,
     );
   });
 
-  it('should handle empty input directory', async () => {
+  it("should handle empty input directory", async () => {
     await assert.rejects(
       () =>
-        execFileAsync('node', [
-          join(process.cwd(), 'lib', 'index.mjs'),
-          '-i',
+        execFileAsync("node", [
+          join(process.cwd(), "lib", "index.mjs"),
+          "-i",
           inputDir,
-          '-o',
-          outputDir
+          "-o",
+          outputDir,
         ]),
-      /An error has occurred/
+      /An error has occurred/,
     );
   });
 });

package/lib/modules/copyAssets.mjs

@@ -1,7 +1,7 @@
-import { cp, readdir } from 'node:fs/promises';
-import { join } from 'node:path';
-import { EMOJI, EXCLUSIONS } from '../helpers/constants.mjs';
-import Logger from '../helpers/logger.mjs';
+import { cp, readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { EMOJI, EXCLUSIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const copyAssets = async ({ inputDir, outputDir }) => {
   const assets = await readdir(inputDir);
@@ -12,20 +12,20 @@ const copyAssets = async ({ inputDir, outputDir }) => {
   }
 
   Logger.message(
-    `${EMOJI.cardIndexDividers}  Copying ${filteredAssets.length} assets…`
+    `${EMOJI.cardIndexDividers}  Copying ${filteredAssets.length} assets…`,
   );
 
   await Promise.all(
     filteredAssets.map(async (asset) => {
       await cp(join(inputDir, asset), join(outputDir, asset), {
-        recursive: true
+        recursive: true,
       });
-    })
+    }),
   );
 
   Logger.message(
-    `${EMOJI.cardIndexDividers}  Copied ${filteredAssets.length} assets\n`,
-    true
+    `${EMOJI.cardIndexDividers}  Copied ${filteredAssets.length} assets`,
+    true,
   );
 };
 

package/lib/modules/copyAssets.test.mjs

@@ -1,55 +1,55 @@
-import assert from 'node:assert/strict';
-import { mkdir, readdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { EMOJI } from '../helpers/constants.mjs';
+import assert from "node:assert/strict";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
 import {
   inputCSS,
   inputDir,
   inputHTML,
   inputJS,
   outputDir,
-  setUpTestHooks
-} from '../helpers/tests.mjs';
-import copyAssets from './copyAssets.mjs';
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import copyAssets from "./copyAssets.mjs";
 
 describe(`${EMOJI.cardIndexDividers}  copyAssets()`, () => {
   setUpTestHooks();
 
-  it('should copy all non-excluded assets', async () => {
-    await writeFile(join(inputDir, 'image.png'), '');
-    await writeFile(join(inputDir, 'document.pdf'), '');
-    await writeFile(join(inputDir, 'script.js'), inputJS);
+  it("should copy all non-excluded assets", async () => {
+    await writeFile(join(inputDir, "image.png"), "");
+    await writeFile(join(inputDir, "document.pdf"), "");
+    await writeFile(join(inputDir, "script.js"), inputJS);
 
     await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
 
     const copiedFiles = await readdir(outputDir);
 
     assert.deepEqual(copiedFiles.sort(), [
-      'document.pdf',
-      'image.png',
-      'script.js'
+      "document.pdf",
+      "image.png",
+      "script.js",
     ]);
   });
 
-  it('should exclude files listed in EXCLUSIONS', async () => {
-    await mkdir(join(inputDir, 'scripts'), { recursive: true });
-    await mkdir(join(inputDir, 'styles'), { recursive: true });
-    await writeFile(join(inputDir, 'image.png'), '');
-    await writeFile(join(inputDir, 'index.html'), inputHTML);
-    await writeFile(join(inputDir, 'script.hash.js'), inputJS);
-    await writeFile(join(inputDir, 'style.hash.css'), inputCSS);
-    await writeFile(join(inputDir, 'scripts', 'app.js'), inputJS);
-    await writeFile(join(inputDir, 'styles', 'main.css'), inputCSS);
+  it("should exclude files listed in EXCLUSIONS", async () => {
+    await mkdir(join(inputDir, "scripts"), { recursive: true });
+    await mkdir(join(inputDir, "styles"), { recursive: true });
+    await writeFile(join(inputDir, "image.png"), "");
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
+    await writeFile(join(inputDir, "scripts", "app.js"), inputJS);
+    await writeFile(join(inputDir, "styles", "main.css"), inputCSS);
 
     await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
 
     const copiedFiles = await readdir(outputDir);
 
-    assert.deepStrictEqual(copiedFiles, ['image.png']);
+    assert.deepStrictEqual(copiedFiles, ["image.png"]);
   });
 
-  it('should handle empty input directory', async () => {
+  it("should handle empty input directory", async () => {
     await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
 
     const copiedFiles = await readdir(outputDir);
@@ -57,25 +57,25 @@ describe(`${EMOJI.cardIndexDividers}  copyAssets()`, () => {
     assert.deepStrictEqual(copiedFiles, []);
   });
 
-  it('should copy directories recursively', async () => {
-    await mkdir(join(inputDir, 'assets'), { recursive: true });
-    await mkdir(join(inputDir, 'assets', 'images'), { recursive: true });
-    await writeFile(join(inputDir, 'assets', 'file.txt'), '');
-    await writeFile(join(inputDir, 'assets', 'images', 'logo.png'), '');
+  it("should copy directories recursively", async () => {
+    await mkdir(join(inputDir, "assets"), { recursive: true });
+    await mkdir(join(inputDir, "assets", "images"), { recursive: true });
+    await writeFile(join(inputDir, "assets", "file.txt"), "");
+    await writeFile(join(inputDir, "assets", "images", "logo.png"), "");
 
     await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
 
     const copiedFiles = await readdir(outputDir, { withFileTypes: true });
-    const assetsDir = copiedFiles.find((f) => f.name === 'assets');
-    const subFiles = await readdir(join(outputDir, 'assets'));
+    const assetsDir = copiedFiles.find((f) => f.name === "assets");
+    const subFiles = await readdir(join(outputDir, "assets"));
 
     assert.ok(assetsDir.isDirectory());
-    assert.deepStrictEqual(subFiles.sort(), ['file.txt', 'images']);
+    assert.deepStrictEqual(subFiles.sort(), ["file.txt", "images"]);
   });
 
-  it('should handle only excluded files', async () => {
-    await writeFile(join(inputDir, 'index.html'), inputHTML);
-    await writeFile(join(inputDir, 'script.hash.js'), inputCSS);
+  it("should handle only excluded files", async () => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
+    await writeFile(join(inputDir, "script.hash.js"), inputCSS);
 
     await assert.doesNotReject(() => copyAssets({ inputDir, outputDir }));
 

package/lib/modules/index.mjs

@@ -1,7 +1,7 @@
-import copyAssets from './copyAssets.mjs';
-import preflight from './preflight.mjs';
-import processCSS from './processCSS.mjs';
-import processHTML from './processHTML.mjs';
-import processJS from './processJS.mjs';
+import copyAssets from "./copyAssets.mjs";
+import preflight from "./preflight.mjs";
+import processCSS from "./processCSS.mjs";
+import processHTML from "./processHTML.mjs";
+import processJS from "./processJS.mjs";
 
 export { copyAssets, preflight, processCSS, processHTML, processJS };

package/lib/modules/preflight.mjs

@@ -1,6 +1,6 @@
-import { mkdir, readdir, rm } from 'node:fs/promises';
-import { EMOJI } from '../helpers/constants.mjs';
-import Logger from '../helpers/logger.mjs';
+import { mkdir, readdir, rm } from "node:fs/promises";
+import { EMOJI } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const preflight = async (outputDir) => {
   try {
@@ -13,22 +13,22 @@ const preflight = async (outputDir) => {
       await mkdir(outputDir);
 
       Logger.message(
-        `${EMOJI.wastebasket} Removed old ${outputDir} files\n`,
-        true
+        `${EMOJI.wastebasket} Removed old ${outputDir} files`,
+        true,
       );
     }
   } catch (error) {
-    if (error.code === 'ENOENT') {
+    if (error.code === "ENOENT") {
       Logger.message(`${EMOJI.fileFolder} Creating ${outputDir} directory…`);
 
       await mkdir(outputDir);
 
       Logger.message(
-        `${EMOJI.fileFolder} Created ${outputDir} directory\n`,
-        true
+        `${EMOJI.fileFolder} Created ${outputDir} directory`,
+        true,
       );
     } else {
-      Logger.error(`${error} \n`);
+      Logger.error(error);
     }
   }
 };

package/lib/modules/preflight.test.mjs

@@ -1,16 +1,16 @@
-import assert from 'node:assert/strict';
-import { mkdir, readdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { EMOJI } from '../helpers/constants.mjs';
-import { outputDir, setUpTestHooks } from '../helpers/tests.mjs';
-import preflight from './preflight.mjs';
+import assert from "node:assert/strict";
+import { mkdir, readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
+import { outputDir, setUpTestHooks } from "../helpers/tests.mjs";
+import preflight from "./preflight.mjs";
 
 describe(`${EMOJI.fileFolder} preflight()`, () => {
   setUpTestHooks();
 
-  it('should create output directory if it does not exist', async () => {
-    const nonExistentDir = join(outputDir, 'non-existent');
+  it("should create output directory if it does not exist", async () => {
+    const nonExistentDir = join(outputDir, "non-existent");
     await assert.doesNotReject(() => preflight(nonExistentDir));
 
     const files = await readdir(nonExistentDir);
@@ -19,11 +19,11 @@ describe(`${EMOJI.fileFolder} preflight()`, () => {
     assert.deepEqual(files, []);
   });
 
-  it('should remove all files and recreate output directory', async () => {
-    await mkdir(join(outputDir, 'subdir'), { recursive: true });
-    await writeFile(join(outputDir, 'file1.txt'), '');
-    await writeFile(join(outputDir, 'file2.txt'), '');
-    await writeFile(join(outputDir, 'subdir', 'file3.txt'), '');
+  it("should remove all files and recreate output directory", async () => {
+    await mkdir(join(outputDir, "subdir"), { recursive: true });
+    await writeFile(join(outputDir, "file1.txt"), "");
+    await writeFile(join(outputDir, "file2.txt"), "");
+    await writeFile(join(outputDir, "subdir", "file3.txt"), "");
 
     const initialFiles = await readdir(outputDir, { withFileTypes: true });
 

package/lib/modules/processCSS.mjs

@@ -1,12 +1,12 @@
-import cssnanoPlugin from 'cssnano';
-import { readdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import postcss from 'postcss';
-import atImport from 'postcss-import';
-import postcssPresetEnv from 'postcss-preset-env';
-import url from 'postcss-url';
-import { EMOJI, OPTIONS } from '../helpers/constants.mjs';
-import Logger from '../helpers/logger.mjs';
+import cssnanoPlugin from "cssnano";
+import { readdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import postcss from "postcss";
+import atImport from "postcss-import";
+import postcssPresetEnv from "postcss-preset-env";
+import url from "postcss-url";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const { cssnano, url: cssUrl } = OPTIONS.postcss;
 
@@ -18,7 +18,7 @@ const postcssProcessor = postcss()
 
 const processCSS = async ({ inputDir, outputDir }) => {
   const assets = await readdir(inputDir);
-  const file = 'style.hash.css';
+  const file = "style.hash.css";
 
   if (!assets.includes(file)) {
     return;
@@ -28,15 +28,15 @@ const processCSS = async ({ inputDir, outputDir }) => {
 
   const input = join(inputDir, file);
   const output = join(outputDir, file);
-  const data = await readFile(input, { encoding: 'utf8' });
-  const code = await _processData(input, data);
+  const data = await readFile(input, { encoding: "utf8" });
+  const code = await processCSSData(input, data);
 
   await writeFile(output, code);
 
-  Logger.message(`${EMOJI.artistPalette} Processed styles\n`, true);
+  Logger.message(`${EMOJI.artistPalette} Processed styles`, true);
 };
 
-async function _processData(input, data) {
+export async function processCSSData(input, data) {
   const { css } = await postcssProcessor.process(data, { from: input });
 
   return css;

package/lib/modules/processCSS.test.mjs

@@ -1,60 +1,60 @@
-import assert from 'node:assert/strict';
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { EMOJI } from '../helpers/constants.mjs';
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
 import {
   inputCSS,
   inputDir,
   outputDir,
   processedCSS,
-  setUpTestHooks
-} from '../helpers/tests.mjs';
-import processCSS from './processCSS.mjs';
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processCSS from "./processCSS.mjs";
 
 describe(`${EMOJI.artistPalette} processCSS()`, () => {
   setUpTestHooks();
 
-  it('should process CSS file and write output', async (sub) => {
-    await writeFile(join(inputDir, 'style.hash.css'), inputCSS);
+  it("should process CSS file and write output", async (sub) => {
+    await writeFile(join(inputDir, "style.hash.css"), inputCSS);
 
     await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'style.hash.css'), 'utf8');
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
 
-    sub.test('minimized as a single line', () => {
+    sub.test("minimized as a single line", () => {
       assert.equal(output, processedCSS);
     });
-    sub.test('with whitespace trimmed', () => {
+    sub.test("with whitespace trimmed", () => {
       assert.ok(output.trim().length < inputCSS.trim().length);
     });
-    sub.test('with comments removed', () => {
+    sub.test("with comments removed", () => {
       assert.doesNotMatch(output, /\/\*\*/);
     });
   });
 
-  it('should handle CSS imports', async () => {
-    await writeFile(join(inputDir, 'style.hash.css'), '@import "base.css";');
-    await writeFile(join(inputDir, 'base.css'), inputCSS);
+  it("should handle CSS imports", async () => {
+    await writeFile(join(inputDir, "style.hash.css"), '@import "base.css";');
+    await writeFile(join(inputDir, "base.css"), inputCSS);
 
     await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'style.hash.css'), 'utf8');
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
 
     assert.ok(output.includes(processedCSS));
   });
 
-  it('should handle empty CSS file', async () => {
-    await writeFile(join(inputDir, 'style.hash.css'), '');
+  it("should handle empty CSS file", async () => {
+    await writeFile(join(inputDir, "style.hash.css"), "");
 
     await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'style.hash.css'), 'utf8');
+    const output = await readFile(join(outputDir, "style.hash.css"), "utf8");
 
-    assert.equal(output, '');
+    assert.equal(output, "");
   });
 
-  it('should skip processing if CSS file does not exist', async () => {
+  it("should skip processing if CSS file does not exist", async () => {
     await assert.doesNotReject(() => processCSS({ inputDir, outputDir }));
   });
 });

package/lib/modules/processHTML.mjs

@@ -1,37 +1,40 @@
-import htmlnano from 'htmlnano';
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import posthtml from 'posthtml';
-import { hash } from 'posthtml-hash';
-import { EMOJI, OPTIONS } from '../helpers/constants.mjs';
-import Logger from '../helpers/logger.mjs';
+import htmlnano from "htmlnano";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import posthtml from "posthtml";
+import { hash } from "posthtml-hash";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
+import { processCSSData } from "./processCSS.mjs";
+import { processJSData } from "./processJS.mjs";
 
 const { htmlnano: htmlnanoOptions } = OPTIONS.posthtml;
 
 const processHTML = async ({ inputDir, outputDir }) => {
   Logger.message(`${EMOJI.fileCabinet} Processing HTML…`);
-  const file = 'index.html';
+  const file = "index.html";
   const input = join(inputDir, file);
   const output = join(outputDir, file);
 
-  const data = await readFile(input, { encoding: 'utf8' });
-  const code = await _processData(outputDir, data);
+  const data = await readFile(input, { encoding: "utf8" });
+  const code = await processHTMLData(outputDir, data);
 
   await writeFile(output, code);
 
-  Logger.message(`${EMOJI.fileCabinet} Processed HTML\n`, true);
+  Logger.message(`${EMOJI.fileCabinet} Processed HTML`, true);
 };
 
-async function _processData(path, data) {
-  let posthtmlInstance = posthtml().use(
-    htmlnano(htmlnanoOptions, htmlnano.presets.safe)
-  );
+async function processHTMLData(path, data) {
+  let posthtmlInstance = posthtml()
+    .use(processInlineStyles())
+    .use(processInlineScripts())
+    .use(htmlnano(htmlnanoOptions, htmlnano.presets.safe));
 
   /* node:coverage disable */
-  // Skip hash replacement during tests
-  if (process.env.NODE_ENV !== 'test') {
+  // Do not perform hash replacement when running tests
+  if (process.env.NODE_ENV !== "test") {
     posthtmlInstance = posthtmlInstance.use(
-      hash({ path, pattern: new RegExp(/hash/) })
+      hash({ path, pattern: new RegExp(/hash/) }),
     );
   }
   /* node:coverage enable */
@@ -41,4 +44,48 @@ async function _processData(path, data) {
   return html;
 }
 
+/* node:coverage disable */
+function processInlineContent(tagName, shouldProcess, processFn) {
+  return function () {
+    return async function (tree) {
+      const itemsToProcess = [];
+
+      tree.walk((node) => {
+        if (node.tag === tagName && shouldProcess(node)) {
+          const content = Array.isArray(node.content)
+            ? node.content.join("")
+            : node.content;
+
+          itemsToProcess.push({ node, content });
+        }
+
+        return node;
+      });
+
+      await Promise.all(
+        itemsToProcess.map(async ({ node, content }) => {
+          node.content = await processFn(content);
+        }),
+      );
+    };
+  };
+}
+/* node:coverage enable */
+
+/* node:coverage disable */
+const processInlineScripts = processInlineContent(
+  "script",
+  (node) => node.content && !node.attrs?.src,
+  processJSData,
+);
+/* node:coverage enable */
+
+/* node:coverage disable */
+const processInlineStyles = processInlineContent(
+  "style",
+  (node) => node.content,
+  (content) => processCSSData(null, content),
+);
+/* node:coverage enable */
+
 export default processHTML;

package/lib/modules/processHTML.test.mjs

@@ -1,50 +1,50 @@
-import assert from 'node:assert/strict';
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { EMOJI } from '../helpers/constants.mjs';
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
 import {
   inputDir,
   inputHTML,
   outputDir,
   processedHTML,
-  setUpTestHooks
-} from '../helpers/tests.mjs';
-import processHTML from './processHTML.mjs';
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processHTML from "./processHTML.mjs";
 
 describe(`${EMOJI.fileCabinet} processHTML()`, () => {
   setUpTestHooks();
 
-  it('should process HTML file and write output', async (sub) => {
-    await writeFile(join(inputDir, 'index.html'), inputHTML);
+  it("should process HTML file and write output", async (sub) => {
+    await writeFile(join(inputDir, "index.html"), inputHTML);
 
     await assert.doesNotReject(() => processHTML({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'index.html'), 'utf8');
+    const output = await readFile(join(outputDir, "index.html"), "utf8");
 
-    sub.test('minimized as a single line', () => {
+    sub.test("minimized as a single line", () => {
       assert.equal(output, processedHTML);
     });
-    sub.test('with whitespace trimmed', () => {
+    sub.test("with whitespace trimmed", () => {
       assert.ok(output.trim().length < inputHTML.trim().length);
-      assert.ok(output.includes('Test Site'));
-      assert.ok(output.includes('Article Title'));
+      assert.ok(output.includes("Test Site"));
+      assert.ok(output.includes("Article Title"));
     });
-    sub.test('with comments removed', () => {
+    sub.test("with comments removed", () => {
       assert.doesNotMatch(output, /<!--/);
     });
-    sub.test('with boolean attributes handled correctly', () => {
-      assert.ok(output.includes('disabled'));
+    sub.test("with boolean attributes handled correctly", () => {
+      assert.ok(output.includes("disabled"));
       assert.doesNotMatch(output, /disabled="disabled"/);
     });
   });
 
-  it('should handle empty HTML file', async () => {
-    await writeFile(join(inputDir, 'index.html'), '');
+  it("should handle empty HTML file", async () => {
+    await writeFile(join(inputDir, "index.html"), "");
     await processHTML({ inputDir, outputDir });
 
-    const output = await readFile(join(outputDir, 'index.html'), 'utf8');
+    const output = await readFile(join(outputDir, "index.html"), "utf8");
 
-    assert.equal(output, '');
+    assert.equal(output, "");
   });
 });

package/lib/modules/processJS.mjs

@@ -1,16 +1,16 @@
-import { transformFromAstAsync } from '@babel/core';
-import { parse } from '@babel/parser';
-import { readdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { rollup } from 'rollup';
-import { EMOJI, OPTIONS } from '../helpers/constants.mjs';
-import Logger from '../helpers/logger.mjs';
+import { transformFromAstAsync } from "@babel/core";
+import { parse } from "@babel/parser";
+import { readdir, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { rollup } from "rollup";
+import { EMOJI, OPTIONS } from "../helpers/constants.mjs";
+import Logger from "../helpers/logger.mjs";
 
 const { babel: babelOptions, rollup: rollupOptions } = OPTIONS;
 
 const processJS = async ({ inputDir, outputDir }) => {
   const assets = await readdir(inputDir);
-  const file = 'script.hash.js';
+  const file = "script.hash.js";
 
   if (!assets.includes(file)) {
     return;
@@ -20,28 +20,28 @@ const processJS = async ({ inputDir, outputDir }) => {
 
   const input = join(inputDir, file);
   const output = join(outputDir, file);
-  const bundledCode = await _bundleJS(input);
-  const code = await _processData(bundledCode);
+  const bundledCode = await bundleJS(input);
+  const code = await processJSData(bundledCode);
 
   await writeFile(output, code);
 
-  Logger.message(`${EMOJI.barChart} Processed scripts\n`, true);
+  Logger.message(`${EMOJI.barChart} Processed scripts`, true);
 };
 
-async function _bundleJS(input) {
+async function bundleJS(input) {
   const bundle = await rollup({
     input,
-    ...rollupOptions
+    ...rollupOptions,
   });
-  const { output } = await bundle.generate({ format: 'es' });
+  const { output } = await bundle.generate({ format: "es" });
 
   await bundle.close();
 
   return output[0].code;
 }
 
-async function _processData(data) {
-  const ast = parse(data, { sourceType: 'module' });
+export async function processJSData(data) {
+  const ast = parse(data, { sourceType: "module" });
   const { code } = await transformFromAstAsync(ast, data, babelOptions);
 
   return code;

package/lib/modules/processJS.test.mjs

@@ -1,67 +1,67 @@
-import assert from 'node:assert/strict';
-import { readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { describe, it } from 'node:test';
-import { EMOJI } from '../helpers/constants.mjs';
+import assert from "node:assert/strict";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describe, it } from "node:test";
+import { EMOJI } from "../helpers/constants.mjs";
 import {
   inputDir,
   inputJS,
   outputDir,
   processedJS,
-  setUpTestHooks
-} from '../helpers/tests.mjs';
-import processJS from './processJS.mjs';
+  setUpTestHooks,
+} from "../helpers/tests.mjs";
+import processJS from "./processJS.mjs";
 
 describe(`${EMOJI.barChart} processJS()`, () => {
   setUpTestHooks();
 
-  it('should process JavaScript file and write output', async (sub) => {
-    await writeFile(join(inputDir, 'script.hash.js'), inputJS);
+  it("should process JavaScript file and write output", async (sub) => {
+    await writeFile(join(inputDir, "script.hash.js"), inputJS);
 
     await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'script.hash.js'), 'utf8');
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
 
-    sub.test('minimized as a single line', () => {
+    sub.test("minimized as a single line", () => {
       assert.equal(output, processedJS);
     });
-    sub.test('with whitespace trimmed', () => {
+    sub.test("with whitespace trimmed", () => {
       assert.ok(output.trim().length < inputJS.trim().length);
     });
-    sub.test('with comments removed', () => {
+    sub.test("with comments removed", () => {
       assert.doesNotMatch(output, /\/\/ This is a comment/);
       assert.doesNotMatch(output, /\/\*\*/);
     });
   });
 
-  it('should bundle ES modules', async () => {
+  it("should bundle ES modules", async () => {
     await writeFile(
-      join(inputDir, 'script.hash.js'),
+      join(inputDir, "script.hash.js"),
       `
       import sum from './input.js';
       console.log(sum(2, 3));
-    `
+    `,
     );
-    await writeFile(join(inputDir, 'input.js'), inputJS);
+    await writeFile(join(inputDir, "input.js"), inputJS);
 
     await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'script.hash.js'), 'utf8');
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
 
-    assert.ok(output.includes('const sum=(a,b)=>{return a+b}'));
+    assert.ok(output.includes("const sum=(a,b)=>{return a+b}"));
   });
 
-  it('should handle empty JavaScript file', async () => {
-    await writeFile(join(inputDir, 'script.hash.js'), '');
+  it("should handle empty JavaScript file", async () => {
+    await writeFile(join(inputDir, "script.hash.js"), "");
 
     await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
 
-    const output = await readFile(join(outputDir, 'script.hash.js'), 'utf8');
+    const output = await readFile(join(outputDir, "script.hash.js"), "utf8");
 
-    assert.equal(output, '');
+    assert.equal(output, "");
   });
 
-  it('should skip processing if JavaScript file does not exist', async () => {
+  it("should skip processing if JavaScript file does not exist", async () => {
     await assert.doesNotReject(() => processJS({ inputDir, outputDir }));
   });
 });

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@zulaica/site-bundler",
   "author": "David Zulaica",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "type": "module",
   "engines": {
-    "node": ">=24.12.0"
+    "node": ">=24.18.0"
   },
   "license": "UNLICENSED",
   "bin": {
@@ -22,7 +22,7 @@
     "lint": "eslint \"lib/**\"",
     "test": "NODE_ENV=test node --test --test-concurrency=1 --require \"./lib/helpers/tests.mjs\"",
     "test:watch": "npm run test -- --watch",
-    "test:coverage": "npm run test -- --experimental-test-coverage"
+    "test:coverage": "npm run test -- --experimental-test-coverage --test-coverage-exclude=\"**/helpers/**\" --test-coverage-exclude=\"**/*.test.mjs\""
   },
   "repository": {
     "type": "git",
@@ -33,29 +33,33 @@
   },
   "homepage": "https://github.com/zulaica/site-bundler#readme",
   "dependencies": {
-    "@babel/core": "7.28.5",
-    "@babel/parser": "7.28.5",
-    "@babel/preset-env": "7.28.5",
-    "commander": "14.0.2",
-    "cssnano": "7.1.2",
-    "cssnano-preset-advanced": "7.0.10",
-    "htmlnano": "3.0.0",
-    "postcss": "8.5.6",
+    "@babel/core": "8.0.1",
+    "@babel/parser": "8.0.4",
+    "@babel/preset-env": "8.0.2",
+    "commander": "15.0.0",
+    "cssnano": "8.0.2",
+    "cssnano-preset-advanced": "8.0.2",
+    "htmlnano": "3.4.0",
+    "postcss": "8.5.20",
     "postcss-import": "16.1.1",
-    "postcss-preset-env": "10.5.0",
-    "postcss-url": "10.1.3",
+    "postcss-preset-env": "11.3.2",
+    "postcss-url": "10.1.4",
     "posthtml": "0.16.7",
     "posthtml-hash": "1.2.2",
-    "rollup": "4.54.0"
+    "rollup": "4.62.2"
   },
   "devDependencies": {
-    "eslint": "9.39.2",
+    "@eslint/js": "10.0.1",
+    "eslint": "10.7.0",
     "eslint-config-prettier": "10.1.8",
-    "eslint-plugin-prettier": "5.5.4",
-    "globals": "16.5.0",
-    "prettier": "3.7.4"
+    "eslint-plugin-prettier": "5.5.6",
+    "globals": "17.7.0",
+    "prettier": "3.9.5"
   },
   "volta": {
-    "node": "24.12.0"
+    "node": "24.18.0"
+  },
+  "allowScripts": {
+    "fsevents@2.3.3": true
   }
 }