balm-core 5.2.0 → 6.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,2098 @@
+// src/types/index.ts
+var BundlerType = /* @__PURE__ */ ((BundlerType2) => {
+  BundlerType2["webpack"] = "webpack";
+  BundlerType2["rollup"] = "rollup";
+  BundlerType2["esbuild"] = "esbuild";
+  return BundlerType2;
+})(BundlerType || {});
+
+// src/config/index.ts
+import path3 from "path";
+
+// src/config/defaults.ts
+import path from "path";
+function createDefaultConfig(workspace = process.cwd()) {
+  const isProd = process.env.NODE_ENV === "production";
+  const isDev = !isProd;
+  const isTest = process.env.NODE_ENV === "test";
+  const roots = {
+    source: "src",
+    tmp: ".tmp",
+    target: "dist"
+  };
+  const paths = {
+    source: {
+      base: "",
+      html: "",
+      css: "styles",
+      js: "scripts",
+      img: "images",
+      font: "fonts",
+      media: "media"
+    },
+    tmp: {
+      base: "",
+      css: "css",
+      js: "js",
+      img: "img",
+      font: "fonts",
+      media: "media"
+    },
+    target: {
+      base: "",
+      css: "css",
+      js: "js",
+      img: "img",
+      font: "font",
+      media: "media"
+    }
+  };
+  const alias = {
+    "@": path.join(workspace, roots.source)
+  };
+  const styles = {
+    extname: "scss",
+    minify: false,
+    atImportPaths: [],
+    alias: {},
+    options: {},
+    sassOptions: {},
+    lessOptions: {},
+    postcssLoaderOptions: {},
+    postcssPlugins: [],
+    sprites: [],
+    spriteOptions: {}
+  };
+  const scripts = {
+    bundler: "webpack" /* webpack */,
+    minify: false,
+    minifyOptions: {},
+    entry: "",
+    target: "web",
+    library: "",
+    libraryTarget: "var",
+    externals: {},
+    injectHtml: false,
+    htmlName: "index.html",
+    alias: {},
+    plugins: [],
+    loaders: [],
+    defaultLoaders: {
+      html: true,
+      css: true,
+      js: true,
+      url: true
+    },
+    options: {},
+    esbuildOptions: {},
+    rollupOptions: {},
+    webpackOptions: {},
+    useCache: false
+  };
+  const html = {
+    options: {
+      collapseWhitespace: true,
+      minifyCSS: true,
+      minifyJS: {
+        compress: {
+          drop_console: true
+        }
+      },
+      processConditionalComments: true,
+      removeComments: true,
+      removeEmptyAttributes: true,
+      removeScriptTypeAttributes: true,
+      removeStyleLinkTypeAttributes: true
+    }
+  };
+  const assets = {
+    root: "assets",
+    mainDir: "public",
+    subDir: "",
+    buildDir: "build",
+    virtualDir: "",
+    cache: false,
+    options: {
+      fileNameManifest: "rev-manifest.json",
+      dontRenameFile: [".html"],
+      dontUpdateReference: []
+    },
+    includes: [],
+    excludes: []
+  };
+  const server = {
+    host: null,
+    port: 3e3,
+    open: true,
+    proxy: false,
+    proxyOptions: false,
+    historyOptions: false,
+    useHMR: false,
+    options: {}
+  };
+  const pwa = {
+    enabled: false,
+    mode: "generateSW",
+    version: "",
+    manifest: "manifest.json",
+    swSrcFilename: "service-worker.js",
+    swDestFilename: "sw.js",
+    options: {}
+  };
+  const ftp = {
+    options: {},
+    watchFiles: []
+  };
+  const images = {
+    plugins: []
+  };
+  const env = {
+    isProd,
+    isDev,
+    isTest,
+    inFrontend: true,
+    inSSR: false,
+    inDesktopApp: false,
+    isMP: false
+  };
+  const src = {
+    base: path.join(workspace, roots.source),
+    html: path.join(workspace, roots.source, paths.source.html),
+    css: path.join(workspace, roots.source, paths.source.css),
+    js: path.join(workspace, roots.source, paths.source.js),
+    img: path.join(workspace, roots.source, paths.source.img),
+    font: path.join(workspace, roots.source, paths.source.font),
+    media: path.join(workspace, roots.source, paths.source.media)
+  };
+  const targetBase = path.join(workspace, isProd ? roots.target : roots.tmp);
+  const dest = {
+    base: targetBase,
+    html: targetBase,
+    css: path.join(targetBase, isProd ? paths.target.css : paths.tmp.css),
+    js: path.join(targetBase, isProd ? paths.target.js : paths.tmp.js),
+    img: path.join(targetBase, isProd ? paths.target.img : paths.tmp.img),
+    font: path.join(targetBase, isProd ? paths.target.font : paths.tmp.font),
+    media: path.join(targetBase, isProd ? paths.target.media : paths.tmp.media),
+    static: path.join(targetBase, assets.virtualDir, assets.subDir)
+  };
+  return {
+    workspace,
+    workspaces: {
+      local: workspace,
+      global: path.resolve(workspace, "..")
+    },
+    alias,
+    env,
+    inFrontend: true,
+    useDefaults: true,
+    roots,
+    paths,
+    styles,
+    scripts,
+    html,
+    assets,
+    server,
+    pwa,
+    ftp,
+    images,
+    logs: {
+      level: 1
+    },
+    src,
+    dest
+  };
+}
+
+// src/utilities/utils.ts
+function isObject(val) {
+  return val !== null && typeof val === "object" && !Array.isArray(val);
+}
+function isArray(val) {
+  return Array.isArray(val);
+}
+function isString(val) {
+  return typeof val === "string";
+}
+function isFunction(val) {
+  return typeof val === "function";
+}
+function isBoolean(val) {
+  return typeof val === "boolean";
+}
+function deepMerge(target, ...sources) {
+  if (!sources.length) return target;
+  const source = sources.shift();
+  if (isObject(target) && isObject(source)) {
+    for (const key in source) {
+      if (isObject(source[key])) {
+        if (!target[key]) Object.assign(target, { [key]: {} });
+        deepMerge(target[key], source[key]);
+      } else if (isArray(source[key])) {
+        target[key] = [...source[key]];
+      } else if (source[key] !== void 0) {
+        Object.assign(target, { [key]: source[key] });
+      }
+    }
+  }
+  return deepMerge(target, ...sources);
+}
+function toNamespace(name, namespace = "balm") {
+  if (isArray(name)) {
+    return name.map((item) => `${namespace}:${item}`);
+  }
+  return `${namespace}:${name}`;
+}
+
+// src/config/constants.ts
+var ASSETS_TYPES = ["css", "js", "img", "font", "media"];
+var PUBLIC_URL = "%PUBLIC_URL%";
+var CHUNK = { dir: "chunk" };
+var ASSET = { dir: "asset" };
+var ASSET_EXT = {
+  styles: ["css", "scss", "sass", "less"],
+  scripts: ["js", "mjs", "cjs", "ts", "mts", "cts", "jsx", "tsx"],
+  images: ["png", "jpg", "jpeg", "gif", "svg", "webp", "ico"],
+  fonts: ["woff", "woff2", "ttf", "eot", "otf"],
+  media: ["mp4", "webm", "ogg", "mp3", "wav", "flac", "aac"]
+};
+
+// src/utilities/workspace.ts
+import path2 from "path";
+var currentLocalWorkspace = process.cwd();
+var currentGlobalWorkspace = path2.resolve(process.cwd(), "..");
+function setWorkspaces(local, global) {
+  if (local) {
+    currentLocalWorkspace = path2.resolve(local);
+  }
+  if (global) {
+    currentGlobalWorkspace = path2.resolve(global);
+  } else if (local && !global) {
+    currentGlobalWorkspace = path2.resolve(currentLocalWorkspace, "..");
+  }
+}
+function getWorkspaces() {
+  return {
+    local: currentLocalWorkspace,
+    global: currentGlobalWorkspace
+  };
+}
+function localWorkspace(subPath = "") {
+  return subPath ? path2.resolve(currentLocalWorkspace, subPath) : currentLocalWorkspace;
+}
+function globalWorkspace(subPath = "") {
+  return subPath ? path2.resolve(currentGlobalWorkspace, subPath) : currentGlobalWorkspace;
+}
+var localResolve = localWorkspace;
+var globalResolve = globalWorkspace;
+
+// src/config/index.ts
+function resolveConfig(customConfig = {}, defaultWorkspace = process.cwd()) {
+  let localWorkspace2 = defaultWorkspace;
+  let globalWorkspace2 = path3.resolve(defaultWorkspace, "..");
+  if (customConfig.workspace) {
+    if (typeof customConfig.workspace === "string") {
+      localWorkspace2 = path3.resolve(customConfig.workspace);
+      globalWorkspace2 = path3.resolve(localWorkspace2, "..");
+    } else if (typeof customConfig.workspace === "object") {
+      localWorkspace2 = path3.resolve(customConfig.workspace.local || defaultWorkspace);
+      globalWorkspace2 = path3.resolve(
+        customConfig.workspace.global || path3.resolve(localWorkspace2, "..")
+      );
+    }
+  }
+  setWorkspaces(localWorkspace2, globalWorkspace2);
+  const defaultConfig = createDefaultConfig(localWorkspace2);
+  const config = deepMerge(defaultConfig, customConfig);
+  config.workspace = localWorkspace2;
+  config.workspaces = {
+    local: localWorkspace2,
+    global: globalWorkspace2
+  };
+  config.src = {
+    base: path3.join(config.workspace, config.roots.source),
+    html: path3.join(config.workspace, config.roots.source, config.paths.source.html),
+    css: path3.join(config.workspace, config.roots.source, config.paths.source.css),
+    js: path3.join(config.workspace, config.roots.source, config.paths.source.js),
+    img: path3.join(config.workspace, config.roots.source, config.paths.source.img),
+    font: path3.join(config.workspace, config.roots.source, config.paths.source.font),
+    media: path3.join(config.workspace, config.roots.source, config.paths.source.media)
+  };
+  const targetBase = path3.join(
+    config.workspace,
+    config.env.isProd || !config.inFrontend ? config.roots.target : config.roots.tmp
+  );
+  const isProd = config.env.isProd || !config.inFrontend;
+  const pathMap = isProd ? config.paths.target : config.paths.tmp;
+  const destStatic = path3.join(
+    targetBase,
+    config.assets.virtualDir,
+    config.assets.subDir
+  );
+  config.dest = {
+    base: targetBase,
+    html: targetBase,
+    css: path3.join(targetBase, pathMap.css),
+    js: path3.join(targetBase, pathMap.js),
+    img: path3.join(targetBase, pathMap.img),
+    font: path3.join(targetBase, pathMap.font),
+    media: path3.join(targetBase, pathMap.media),
+    static: destStatic
+  };
+  config.assets.static = path3.join(
+    config.assets.root,
+    config.assets.mainDir,
+    config.assets.subDir
+  );
+  for (const assetType of ASSETS_TYPES) {
+    config.assets[assetType] = path3.join(
+      config.assets.static,
+      config.paths.target[assetType]
+    );
+  }
+  const hmrEnv = config.useDefaults && config.env.isDev && !config.env.inSSR && !config.env.isMP;
+  const hmrEnabling = config.scripts.bundler === "webpack";
+  config.server.useHMR = hmrEnv && hmrEnabling;
+  if (/^electron-.*/.test(config.scripts.target)) {
+    config.env.inDesktopApp = true;
+  }
+  config.scripts.useCache = config.env.isProd && config.assets.cache && config.scripts.injectHtml;
+  return config;
+}
+
+// src/utilities/logger.ts
+import pc from "picocolors";
+var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2[LogLevel2["Debug"] = 0] = "Debug";
+  LogLevel2[LogLevel2["Info"] = 1] = "Info";
+  LogLevel2[LogLevel2["Warn"] = 2] = "Warn";
+  LogLevel2[LogLevel2["Error"] = 3] = "Error";
+  LogLevel2[LogLevel2["Silent"] = 4] = "Silent";
+  return LogLevel2;
+})(LogLevel || {});
+var Logger = class {
+  level = 1 /* Info */;
+  formatTag(tag) {
+    return tag ? pc.cyan(`[${tag}]`) : pc.bgBlue(pc.black(" BalmJS "));
+  }
+  timestamp() {
+    const d = /* @__PURE__ */ new Date();
+    const pad = (n) => n.toString().padStart(2, "0");
+    return pc.gray(`[${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}]`);
+  }
+  debug(tag, message, ...args) {
+    if (this.level <= 0 /* Debug */) {
+      console.log(this.timestamp(), this.formatTag(tag), pc.magenta("\u203B"), message, ...args);
+    }
+  }
+  info(tag, message, ...args) {
+    if (this.level <= 1 /* Info */) {
+      console.log(this.timestamp(), this.formatTag(tag), pc.blue("\u2139"), message, ...args);
+    }
+  }
+  success(tag, message, ...args) {
+    if (this.level <= 1 /* Info */) {
+      console.log(this.timestamp(), this.formatTag(tag), pc.green("\u2714"), pc.green(message), ...args);
+    }
+  }
+  warn(tag, message, ...args) {
+    if (this.level <= 2 /* Warn */) {
+      console.warn(this.timestamp(), this.formatTag(tag), pc.yellow("\u26A0"), pc.yellow(message), ...args);
+    }
+  }
+  error(tag, message, ...args) {
+    if (this.level <= 3 /* Error */) {
+      console.error(this.timestamp(), this.formatTag(tag), pc.red("\u2716"), pc.red(message), ...args);
+    }
+  }
+  time(label) {
+    const start = performance.now();
+    return () => {
+      const duration = (performance.now() - start).toFixed(2);
+      this.info("time", `${label} completed in ${pc.bold(duration + "ms")}`);
+    };
+  }
+};
+var logger = new Logger();
+
+// src/runner/dag.ts
+import pc2 from "picocolors";
+var TaskDAG = class {
+  tasks = /* @__PURE__ */ new Map();
+  registerTask(task) {
+    this.tasks.set(task.name, task);
+  }
+  getTask(name) {
+    return this.tasks.get(name);
+  }
+  hasTask(name) {
+    return this.tasks.has(name);
+  }
+  clear() {
+    this.tasks.clear();
+  }
+  /**
+   * Run a list of tasks in strict series
+   */
+  async runSeries(taskNames, config) {
+    for (const name of taskNames) {
+      await this.executeTask(name, config);
+    }
+  }
+  /**
+   * Run a list of tasks in parallel
+   */
+  async runParallel(taskNames, config) {
+    await Promise.all(taskNames.map((name) => this.executeTask(name, config)));
+  }
+  /**
+   * Execute a single task resolving its dependencies first
+   */
+  async executeTask(taskName, config, executed = /* @__PURE__ */ new Set()) {
+    if (executed.has(taskName)) return;
+    const task = this.tasks.get(taskName);
+    if (!task) {
+      logger.warn("task", `Task ${pc2.bold(taskName)} not found, skipping.`);
+      return;
+    }
+    if (task.deps && task.deps.length > 0) {
+      for (const dep of task.deps) {
+        await this.executeTask(dep, config, executed);
+      }
+    }
+    const start = performance.now();
+    try {
+      await task.run(config);
+      executed.add(taskName);
+      const duration = (performance.now() - start).toFixed(1);
+      if (!task.hidden) {
+        logger.info("task", `${pc2.cyan(task.name)} finished in ${pc2.bold(duration + "ms")}`);
+      }
+    } catch (error) {
+      logger.error("task", `Task ${pc2.bold(task.name)} failed: ${error?.message || error}`);
+      throw error;
+    }
+  }
+};
+
+// src/tasks/clean.ts
+import path5 from "path";
+
+// src/runner/task.ts
+var BaseTask = class {
+  name;
+  deps;
+  description;
+  hidden;
+  constructor(options) {
+    this.name = options.name;
+    this.deps = options.deps || [];
+    this.description = options.description;
+    this.hidden = options.hidden || false;
+  }
+};
+var FunctionTask = class extends BaseTask {
+  fn;
+  constructor(name, fn, deps = []) {
+    super({ name, deps });
+    this.fn = fn;
+  }
+  async run(config) {
+    await this.fn(config);
+  }
+};
+
+// src/utilities/file.ts
+import fs from "fs/promises";
+import { existsSync } from "fs";
+import path4 from "path";
+import crypto from "crypto";
+import fg from "fast-glob";
+var FileSystem = class {
+  workspace = process.cwd();
+  resolveApp(...paths) {
+    return path4.resolve(this.workspace, ...paths);
+  }
+  absPath(filePath) {
+    return path4.isAbsolute(filePath) ? filePath : this.resolveApp(filePath);
+  }
+  absPaths(filePaths) {
+    if (Array.isArray(filePaths)) {
+      return filePaths.map((p) => this.absPath(p));
+    }
+    return this.absPath(filePaths);
+  }
+  async exists(targetPath) {
+    try {
+      await fs.access(this.absPath(targetPath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  existsSync(targetPath) {
+    return existsSync(this.absPath(targetPath));
+  }
+  async ensureDir(dirPath) {
+    await fs.mkdir(this.absPath(dirPath), { recursive: true });
+  }
+  async readFile(filePath, encoding = "utf8") {
+    return fs.readFile(this.absPath(filePath), { encoding });
+  }
+  async readBuffer(filePath) {
+    return fs.readFile(this.absPath(filePath));
+  }
+  async writeFile(filePath, data) {
+    const fullPath = this.absPath(filePath);
+    await this.ensureDir(path4.dirname(fullPath));
+    await fs.writeFile(fullPath, data);
+  }
+  async remove(targetPath) {
+    const targets = Array.isArray(targetPath) ? targetPath : [targetPath];
+    const removed = [];
+    for (const item of targets) {
+      const fullPath = this.absPath(item);
+      try {
+        const stat = await fs.stat(fullPath);
+        if (stat.isDirectory()) {
+          await fs.rm(fullPath, { recursive: true, force: true });
+        } else {
+          await fs.unlink(fullPath);
+        }
+        removed.push(fullPath);
+      } catch {
+      }
+    }
+    return removed;
+  }
+  async copyFile(src, dest) {
+    const srcPath = this.absPath(src);
+    const destPath = this.absPath(dest);
+    await this.ensureDir(path4.dirname(destPath));
+    await fs.copyFile(srcPath, destPath);
+  }
+  async copyDir(srcDir, destDir) {
+    const src = this.absPath(srcDir);
+    const dest = this.absPath(destDir);
+    await this.ensureDir(dest);
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+      const srcItem = path4.join(src, entry.name);
+      const destItem = path4.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        await this.copyDir(srcItem, destItem);
+      } else {
+        await this.copyFile(srcItem, destItem);
+      }
+    }
+  }
+  async matchFiles(patterns, options = {}) {
+    const defaultOptions = {
+      cwd: this.workspace,
+      absolute: true,
+      dot: true,
+      onlyFiles: true
+    };
+    return fg(patterns, { ...defaultOptions, ...options });
+  }
+  hash(content, length = 8) {
+    return crypto.createHash("md5").update(content).digest("hex").slice(0, length);
+  }
+};
+var file = new FileSystem();
+
+// src/tasks/clean.ts
+var CleanTask = class extends BaseTask {
+  constructor() {
+    super({ name: "clean", description: "Clean output directories" });
+  }
+  async run(config) {
+    const targets = [
+      path5.join(config.workspace, config.roots.tmp),
+      path5.join(config.workspace, config.roots.target)
+    ];
+    const deleted = await file.remove(targets);
+    logger.info("clean", `Deleted ${deleted.length} directories`);
+  }
+};
+
+// src/tasks/style.ts
+import path10 from "path";
+
+// src/pipeline/pipeline.ts
+import path7 from "path";
+import fg2 from "fast-glob";
+import fs2 from "fs/promises";
+
+// src/pipeline/file.ts
+import path6 from "path";
+var VirtualFile = class _VirtualFile {
+  cwd;
+  base;
+  path;
+  contents;
+  revPathOriginal;
+  constructor(options) {
+    this.cwd = options.cwd;
+    this.base = options.base;
+    this.path = options.path;
+    this.contents = typeof options.contents === "string" ? Buffer.from(options.contents) : options.contents;
+  }
+  get relative() {
+    return path6.relative(this.base, this.path);
+  }
+  get extname() {
+    return path6.extname(this.path);
+  }
+  set extname(val) {
+    const dir = path6.dirname(this.path);
+    const basename = path6.basename(this.path, this.extname);
+    this.path = path6.join(dir, `${basename}${val.startsWith(".") ? val : `.${val}`}`);
+  }
+  get basename() {
+    return path6.basename(this.path);
+  }
+  set basename(val) {
+    const dir = path6.dirname(this.path);
+    this.path = path6.join(dir, val);
+  }
+  get stem() {
+    return path6.basename(this.path, this.extname);
+  }
+  set stem(val) {
+    const dir = path6.dirname(this.path);
+    this.path = path6.join(dir, `${val}${this.extname}`);
+  }
+  toString(encoding = "utf8") {
+    return this.contents.toString(encoding);
+  }
+  clone() {
+    const cloned = new _VirtualFile({
+      cwd: this.cwd,
+      base: this.base,
+      path: this.path,
+      contents: Buffer.from(this.contents)
+    });
+    cloned.revPathOriginal = this.revPathOriginal;
+    return cloned;
+  }
+};
+
+// src/pipeline/pipeline.ts
+var Pipeline = class _Pipeline {
+  cwd;
+  base;
+  allowEmpty;
+  files = [];
+  transforms = [];
+  constructor(options = {}) {
+    this.cwd = options.cwd || process.cwd();
+    this.base = options.base;
+    this.allowEmpty = options.allowEmpty ?? true;
+  }
+  static from(patterns, options = {}) {
+    const pipeline = new _Pipeline(options);
+    return pipeline.src(patterns);
+  }
+  src(patterns, options = {}) {
+    if (options.cwd) this.cwd = options.cwd;
+    if (options.base) this.base = options.base;
+    if (options.allowEmpty !== void 0) this.allowEmpty = options.allowEmpty;
+    this.transforms.push(async () => {
+      const matched = await fg2(patterns, {
+        cwd: this.cwd,
+        absolute: true,
+        dot: true,
+        onlyFiles: true
+      });
+      if (!matched.length && !this.allowEmpty) {
+        throw new Error(`File not found with pattern: ${patterns}`);
+      }
+      let effectiveBase = this.base;
+      if (!effectiveBase) {
+        const patternArr = Array.isArray(patterns) ? patterns : [patterns];
+        const firstPos = patternArr.find((p) => !p.startsWith("!"));
+        if (firstPos) {
+          const globIdx = firstPos.indexOf("*");
+          if (globIdx !== -1) {
+            effectiveBase = path7.resolve(this.cwd, firstPos.slice(0, globIdx));
+          } else {
+            effectiveBase = path7.resolve(this.cwd, path7.dirname(firstPos));
+          }
+        } else {
+          effectiveBase = this.cwd;
+        }
+      }
+      this.files = await Promise.all(
+        matched.map(async (filePath) => {
+          const buffer = await fs2.readFile(filePath);
+          return new VirtualFile({
+            cwd: this.cwd,
+            base: effectiveBase,
+            path: filePath,
+            contents: buffer
+          });
+        })
+      );
+    });
+    return this;
+  }
+  pipe(transform) {
+    this.transforms.push(transform);
+    return this;
+  }
+  async process() {
+    let isSrcLoaded = false;
+    for (const transform of this.transforms) {
+      if (!isSrcLoaded) {
+        await transform(null);
+        isSrcLoaded = true;
+      } else {
+        if (this.files.length === 0) break;
+        const nextFiles = [];
+        for (const file2 of this.files) {
+          const result = await transform(file2);
+          if (result === void 0 || result === file2) {
+            nextFiles.push(file2);
+          } else if (Array.isArray(result)) {
+            nextFiles.push(...result);
+          } else if (result !== null) {
+            nextFiles.push(result);
+          }
+        }
+        this.files = nextFiles;
+      }
+    }
+    return this.files;
+  }
+  async dest(outDir) {
+    const files = await this.process();
+    const writtenPaths = [];
+    const absOutDir = path7.isAbsolute(outDir) ? outDir : path7.resolve(this.cwd, outDir);
+    for (const file2 of files) {
+      const targetPath = path7.resolve(absOutDir, file2.relative);
+      await file.writeFile(targetPath, file2.contents);
+      writtenPaths.push(targetPath);
+    }
+    return writtenPaths;
+  }
+};
+
+// src/pipeline/transforms/sass.ts
+import * as sass from "sass";
+import path8 from "path";
+import fs3 from "fs";
+function resolveFile(baseDir, url) {
+  const possiblePaths = [
+    path8.resolve(baseDir, url),
+    path8.resolve(baseDir, `${url}.scss`),
+    path8.resolve(baseDir, `${url}.sass`),
+    path8.resolve(baseDir, `${url}.css`),
+    path8.resolve(baseDir, path8.dirname(url), `_${path8.basename(url)}.scss`),
+    path8.resolve(baseDir, path8.dirname(url), `_${path8.basename(url)}.sass`),
+    path8.resolve(baseDir, url, "_index.scss"),
+    path8.resolve(baseDir, url, "_index.sass"),
+    path8.resolve(baseDir, url, "index.scss"),
+    path8.resolve(baseDir, url, "index.sass")
+  ];
+  for (const p of possiblePaths) {
+    try {
+      if (fs3.existsSync(p) && fs3.statSync(p).isFile()) {
+        return p;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function transformSass(options = {}) {
+  return async (file2) => {
+    if (!/\.(scss|sass)$/i.test(file2.extname)) return file2;
+    if (path8.basename(file2.path).startsWith("_")) return null;
+    try {
+      const searchDirs = [
+        path8.dirname(file2.path),
+        path8.resolve(file2.cwd, "node_modules"),
+        path8.resolve(process.cwd(), "node_modules"),
+        path8.resolve(process.cwd(), "..", "node_modules"),
+        ...options.includePaths || []
+      ];
+      const customImporter = {
+        findFileUrl(url) {
+          let cleanUrl = url;
+          if (cleanUrl.startsWith("~")) {
+            cleanUrl = cleanUrl.slice(1);
+          }
+          if (options.alias) {
+            for (const [aliasKey, aliasTarget] of Object.entries(options.alias)) {
+              if (cleanUrl === aliasKey) {
+                const resolved = resolveFile(path8.dirname(aliasTarget), path8.basename(aliasTarget));
+                if (resolved) return new URL(`file://${resolved}`);
+              } else if (cleanUrl.startsWith(`${aliasKey}/`)) {
+                const subPath = cleanUrl.slice(aliasKey.length + 1);
+                const resolved = resolveFile(aliasTarget, subPath);
+                if (resolved) return new URL(`file://${resolved}`);
+              }
+            }
+          }
+          for (const dir of searchDirs) {
+            const resolved = resolveFile(dir, cleanUrl);
+            if (resolved) {
+              return new URL(`file://${resolved}`);
+            }
+          }
+          return null;
+        }
+      };
+      const result = await sass.compileStringAsync(file2.toString(), {
+        url: new URL(`file://${file2.path}`),
+        syntax: file2.extname === ".sass" ? "indented" : "scss",
+        loadPaths: searchDirs,
+        importers: [customImporter, new sass.NodePackageImporter()],
+        style: options.style || "expanded",
+        sourceMap: options.sourceMap || false
+      });
+      file2.contents = Buffer.from(result.css);
+      file2.extname = ".css";
+      return file2;
+    } catch (err) {
+      logger.error("sass", `Error compiling ${file2.path}: ${err.message}`);
+      throw err;
+    }
+  };
+}
+
+// src/pipeline/transforms/less.ts
+import less from "less";
+import path9 from "path";
+var AliasFileManager = class extends less.FileManager {
+  alias;
+  constructor(alias = {}) {
+    super();
+    this.alias = alias;
+  }
+  supports(filename) {
+    const clean = filename.startsWith("~") ? filename.slice(1) : filename;
+    return Object.keys(this.alias).some((k) => clean === k || clean.startsWith(`${k}/`));
+  }
+  loadFile(filename, currentDirectory, options, environment) {
+    const clean = filename.startsWith("~") ? filename.slice(1) : filename;
+    for (const [k, v] of Object.entries(this.alias)) {
+      if (clean === k) {
+        return super.loadFile(v, currentDirectory, options, environment);
+      } else if (clean.startsWith(`${k}/`)) {
+        const sub = clean.slice(k.length + 1);
+        return super.loadFile(path9.join(v, sub), currentDirectory, options, environment);
+      }
+    }
+    return super.loadFile(filename, currentDirectory, options, environment);
+  }
+};
+function transformLess(options = {}) {
+  return async (file2) => {
+    if (!/\.less$/i.test(file2.extname)) return file2;
+    if (path9.basename(file2.path).startsWith("_")) return null;
+    try {
+      const paths = [
+        path9.dirname(file2.path),
+        path9.resolve(file2.cwd, "node_modules"),
+        ...options.paths || []
+      ];
+      const plugins = [...options.plugins || []];
+      if (options.alias && Object.keys(options.alias).length > 0) {
+        plugins.push({
+          install: (lessInstance, pluginManager) => {
+            pluginManager.addFileManager(new AliasFileManager(options.alias));
+          }
+        });
+      }
+      const result = await less.render(file2.toString(), {
+        filename: file2.path,
+        paths,
+        ...options,
+        plugins
+      });
+      file2.contents = Buffer.from(result.css);
+      file2.extname = ".css";
+      return file2;
+    } catch (err) {
+      logger.error("less", `Error compiling ${file2.path}: ${err.message}`);
+      throw err;
+    }
+  };
+}
+
+// src/pipeline/transforms/postcss.ts
+import postcss from "postcss";
+import autoprefixer from "autoprefixer";
+import postcssPresetEnv from "postcss-preset-env";
+import cssnano from "cssnano";
+function transformPostcss(options = {}) {
+  const plugins = [
+    ...options.plugins || [],
+    autoprefixer(),
+    postcssPresetEnv()
+  ];
+  if (options.minify) {
+    plugins.push(cssnano({ preset: "default" }));
+  }
+  const processor = postcss(plugins);
+  return async (file2) => {
+    if (!/\.css$/i.test(file2.extname)) return file2;
+    try {
+      const result = await processor.process(file2.toString(), {
+        from: file2.path,
+        to: file2.path
+      });
+      file2.contents = Buffer.from(result.css);
+      return file2;
+    } catch (err) {
+      logger.error("postcss", `Error processing ${file2.path}: ${err.message}`);
+      throw err;
+    }
+  };
+}
+
+// src/tasks/style.ts
+var StyleTask = class extends BaseTask {
+  constructor() {
+    super({ name: "style", description: "Compile stylesheets" });
+  }
+  async run(config) {
+    const ext = config.styles.extname;
+    const srcPattern = path10.join(config.src.css, `**/*.${ext}`);
+    const isProd = config.env.isProd;
+    const pipeline = Pipeline.from([srcPattern, `!${path10.join(config.src.css, "**/_*.scss")}`, `!${path10.join(config.src.css, "**/_*.less")}`], {
+      cwd: config.workspace,
+      base: config.src.css
+    });
+    const styleAlias = {
+      ...config.alias,
+      ...config.styles.alias
+    };
+    if (ext === "scss" || ext === "sass") {
+      pipeline.pipe(
+        transformSass({
+          includePaths: [config.src.css, ...config.styles.atImportPaths],
+          alias: styleAlias,
+          ...config.styles.sassOptions
+        })
+      );
+    } else if (ext === "less") {
+      pipeline.pipe(
+        transformLess({
+          paths: [config.src.css, ...config.styles.atImportPaths],
+          alias: styleAlias,
+          ...config.styles.lessOptions
+        })
+      );
+    }
+    pipeline.pipe(
+      transformPostcss({
+        plugins: config.styles.postcssPlugins,
+        minify: isProd || config.styles.minify,
+        ...config.styles.postcssLoaderOptions
+      })
+    );
+    await pipeline.dest(config.dest.css);
+  }
+};
+
+// src/bundler/webpack.ts
+import webpack from "webpack";
+import path11 from "path";
+async function runWebpack(config, customOptions = {}) {
+  const isProd = config.env.isProd;
+  let entry = customOptions.entry || config.scripts.entry;
+  if (!entry) {
+    entry = path11.join(config.src.js, "main.js");
+  }
+  const defaultWebpackConfig = {
+    mode: isProd ? "production" : "development",
+    context: config.workspace,
+    entry,
+    output: {
+      path: config.dest.js,
+      filename: isProd && config.assets.cache ? "[name].[contenthash:8].js" : "[name].js",
+      chunkFilename: isProd && config.assets.cache ? "chunk/[name].[contenthash:8].js" : "chunk/[name].js",
+      publicPath: config.assets.virtualDir ? `/${config.assets.virtualDir}/` : "/"
+    },
+    resolve: {
+      extensions: [".wasm", ".mjs", ".js", ".jsx", ".ts", ".tsx", ".json"],
+      alias: {
+        ...config.alias,
+        ...config.scripts.alias
+      }
+    },
+    module: {
+      rules: [
+        {
+          test: /\.(png|jpe?g|gif|svg|webp)$/i,
+          type: "asset/resource",
+          generator: {
+            filename: "img/[name].[hash:8][ext]"
+          }
+        },
+        {
+          test: /\.(woff2?|eot|ttf|otf)$/i,
+          type: "asset/resource",
+          generator: {
+            filename: "font/[name].[hash:8][ext]"
+          }
+        }
+      ]
+    },
+    optimization: {
+      minimize: isProd || config.scripts.minify
+    },
+    devtool: isProd ? false : "eval-cheap-module-source-map"
+  };
+  const webpackConfig = Object.assign(
+    {},
+    defaultWebpackConfig,
+    config.scripts.webpackOptions,
+    customOptions
+  );
+  return new Promise((resolve, reject) => {
+    const compiler = webpack(webpackConfig);
+    compiler.run((err, stats) => {
+      if (err) {
+        logger.error("webpack", err.stack || err);
+        return reject(err);
+      }
+      if (stats?.hasErrors()) {
+        const info = stats.toJson();
+        logger.error("webpack", info.errors?.map((e) => e.message).join("\n"));
+        return reject(new Error("Webpack compilation errors"));
+      }
+      resolve(stats);
+    });
+  });
+}
+
+// src/bundler/rollup.ts
+import { rollup } from "rollup";
+import path12 from "path";
+async function runRollup(config, customInputOptions = {}, customOutputOptions = {}) {
+  const isProd = config.env.isProd;
+  let input = customInputOptions.input || config.scripts.entry;
+  if (!input) {
+    input = path12.join(config.src.js, "main.js");
+  }
+  const inputOptions = {
+    input,
+    ...config.scripts.rollupOptions,
+    ...customInputOptions
+  };
+  const outputOptions = {
+    dir: config.dest.js,
+    format: "es",
+    sourcemap: !isProd,
+    ...customOutputOptions
+  };
+  try {
+    const bundle = await rollup(inputOptions);
+    await bundle.write(outputOptions);
+    await bundle.close();
+  } catch (err) {
+    logger.error("rollup", err.message || err);
+    throw err;
+  }
+}
+
+// src/bundler/esbuild.ts
+import * as esbuild from "esbuild";
+import path13 from "path";
+async function runEsbuild(config, customOptions = {}) {
+  const isProd = config.env.isProd;
+  let entryPoints = customOptions.entryPoints || config.scripts.entry;
+  if (!entryPoints) {
+    entryPoints = [path13.join(config.src.js, "main.js")];
+  }
+  const defaultOptions = {
+    entryPoints: Array.isArray(entryPoints) ? entryPoints : typeof entryPoints === "string" ? [entryPoints] : entryPoints,
+    absWorkingDir: config.workspace,
+    bundle: true,
+    outdir: config.dest.js,
+    alias: {
+      ...config.alias,
+      ...config.scripts.alias
+    },
+    minify: isProd || config.scripts.minify,
+    sourcemap: !isProd,
+    target: config.scripts.target && config.scripts.target !== "web" ? config.scripts.target : "es2020",
+    format: "esm",
+    ...config.scripts.esbuildOptions,
+    ...customOptions
+  };
+  try {
+    return await esbuild.build(defaultOptions);
+  } catch (err) {
+    logger.error("esbuild", err.message || err);
+    throw err;
+  }
+}
+
+// src/tasks/script.ts
+var ScriptTask = class extends BaseTask {
+  constructor() {
+    super({ name: "script", description: "Bundle JavaScript/TypeScript" });
+  }
+  async run(config) {
+    const bundler = config.scripts.bundler;
+    switch (bundler) {
+      case "rollup" /* rollup */:
+        await runRollup(config);
+        break;
+      case "esbuild" /* esbuild */:
+        await runEsbuild(config);
+        break;
+      case "webpack" /* webpack */:
+      default:
+        await runWebpack(config);
+        break;
+    }
+  }
+};
+
+// src/tasks/html.ts
+import path14 from "path";
+
+// src/pipeline/transforms/htmlmin.ts
+import { minify } from "html-minifier-terser";
+function transformHtmlmin(options = {}) {
+  return async (file2) => {
+    if (!/\.html$/i.test(file2.extname)) return file2;
+    try {
+      const minified = await minify(file2.toString(), options);
+      file2.contents = Buffer.from(minified);
+      return file2;
+    } catch (err) {
+      logger.error("htmlmin", `Error minifying ${file2.path}: ${err.message}`);
+      throw err;
+    }
+  };
+}
+
+// src/pipeline/transforms/replace.ts
+function transformReplace(options, replacement) {
+  let rules = [];
+  if (Array.isArray(options)) {
+    rules = options;
+  } else if (typeof options === "object" && "substr" in options) {
+    rules = [options];
+  } else if (typeof options === "string" || options instanceof RegExp) {
+    rules = [{ substr: options, replacement: replacement || "" }];
+  }
+  return async (file2) => {
+    let content = file2.toString();
+    for (const rule of rules) {
+      if (typeof rule.replacement === "function") {
+        content = content.replace(rule.substr, rule.replacement);
+      } else {
+        content = content.replace(rule.substr, rule.replacement);
+      }
+    }
+    file2.contents = Buffer.from(content);
+    return file2;
+  };
+}
+
+// src/tasks/html.ts
+var LIVE_RELOAD_SCRIPT = `
+<!-- BalmJS Live Reload -->
+<script>
+(() => {
+  const protocol = location.protocol === 'https:' ? 'wss:' : 'ws:';
+  const ws = new WebSocket(\`\${protocol}//\${location.host}/__balm_ws\`);
+  ws.onmessage = (e) => {
+    try {
+      const msg = JSON.parse(e.data);
+      if (msg.type === 'reload') {
+        console.log('[BalmJS] Reloading page...');
+        location.reload();
+      } else if (msg.type === 'reload-css') {
+        console.log('[BalmJS] Reloading CSS...');
+        const links = document.querySelectorAll('link[rel="stylesheet"]');
+        for (const link of links) {
+          const url = new URL(link.href);
+          url.searchParams.set('_balm_t', Date.now().toString());
+          link.href = url.href;
+        }
+      }
+    } catch {}
+  };
+  ws.onclose = () => {
+    setTimeout(() => location.reload(), 2000);
+  };
+})();
+</script>
+`;
+var HtmlTask = class extends BaseTask {
+  constructor() {
+    super({ name: "html", description: "Process HTML templates" });
+  }
+  async run(config) {
+    const templateDir = config.scripts.injectHtml ? config.src.base : config.src.html;
+    const pattern = path14.join(templateDir, "*.html");
+    const pipeline = Pipeline.from(pattern, {
+      cwd: config.workspace,
+      base: templateDir
+    });
+    const publicUrlReplacement = config.assets.virtualDir ? `/${config.assets.virtualDir}` : "";
+    pipeline.pipe(transformReplace(new RegExp(PUBLIC_URL, "g"), publicUrlReplacement));
+    if (config.env.isProd) {
+      pipeline.pipe(transformHtmlmin(config.html.options));
+    } else {
+      pipeline.pipe(async (file2) => {
+        if (/\.html$/i.test(file2.extname)) {
+          let content = file2.toString();
+          if (content.includes("</body>")) {
+            content = content.replace("</body>", `${LIVE_RELOAD_SCRIPT}
+</body>`);
+          } else {
+            content += `
+${LIVE_RELOAD_SCRIPT}`;
+          }
+          file2.contents = Buffer.from(content);
+        }
+        return file2;
+      });
+    }
+    await pipeline.dest(config.dest.html);
+  }
+};
+
+// src/tasks/copy.ts
+import path16 from "path";
+
+// src/pipeline/transforms/rename.ts
+import path15 from "path";
+function transformRename(options = {}) {
+  return async (file2) => {
+    if (typeof options === "string") {
+      file2.path = path15.resolve(path15.dirname(file2.path), options);
+      return file2;
+    }
+    if (typeof options === "function") {
+      const parsed = {
+        dirname: path15.dirname(file2.path),
+        basename: file2.stem,
+        extname: file2.extname
+      };
+      const result = options(parsed);
+      if (result) {
+        if (result.dirname) file2.path = path15.join(result.dirname, path15.basename(file2.path));
+        if (result.basename) file2.stem = result.basename;
+        if (result.extname) file2.extname = result.extname;
+      }
+      return file2;
+    }
+    const { dirname, prefix = "", basename, suffix = "", extname } = options;
+    const currentDir = dirname ? path15.resolve(file2.cwd, dirname) : path15.dirname(file2.path);
+    const base = basename !== void 0 ? basename : file2.stem;
+    const ext = extname !== void 0 ? extname : file2.extname;
+    file2.path = path15.join(currentDir, `${prefix}${base}${suffix}${ext.startsWith(".") ? ext : `.${ext}`}`);
+    return file2;
+  };
+}
+
+// src/tasks/copy.ts
+var CopyTask = class extends BaseTask {
+  options;
+  constructor(options) {
+    super({ name: "copy", description: "Copy files to destination" });
+    this.options = options;
+  }
+  async run(config) {
+    const pipeline = Pipeline.from(this.options.input, {
+      cwd: config.workspace
+    });
+    if (this.options.rename) {
+      pipeline.pipe(transformRename(this.options.rename));
+    }
+    const outDir = path16.isAbsolute(this.options.output) ? this.options.output : path16.join(config.workspace, this.options.output);
+    await pipeline.dest(outDir);
+  }
+};
+
+// src/tasks/remove.ts
+import path17 from "path";
+var RemoveTask = class extends BaseTask {
+  target;
+  constructor(target) {
+    super({ name: "remove", description: "Remove files and directories" });
+    this.target = target;
+  }
+  async run(config) {
+    const targets = Array.isArray(this.target) ? this.target : [this.target];
+    const resolvedTargets = targets.map(
+      (t) => path17.isAbsolute(t) ? t : path17.join(config.workspace, t)
+    );
+    const deleted = await file.remove(resolvedTargets);
+    logger.warn("remove", `Removed: ${deleted.join(", ")}`);
+  }
+};
+
+// src/tasks/replace.ts
+import path18 from "path";
+var ReplaceTask = class extends BaseTask {
+  taskOptions;
+  constructor(taskOptions) {
+    super({ name: "replace", description: "Replace content in files" });
+    this.taskOptions = taskOptions;
+  }
+  async run(config) {
+    const pipeline = Pipeline.from(this.taskOptions.input, {
+      cwd: config.workspace
+    });
+    pipeline.pipe(transformReplace(this.taskOptions.options));
+    const outDir = path18.isAbsolute(this.taskOptions.output) ? this.taskOptions.output : path18.join(config.workspace, this.taskOptions.output);
+    await pipeline.dest(outDir);
+  }
+};
+
+// src/tasks/cache.ts
+import fg3 from "fast-glob";
+import fs4 from "fs/promises";
+
+// src/pipeline/transforms/cache.ts
+import path19 from "path";
+import picomatch from "picomatch";
+function matchesAny(filePath, rules) {
+  if (!rules || !rules.length) return false;
+  for (const rule of rules) {
+    if (typeof rule === "string") {
+      if (filePath.endsWith(rule) || picomatch.isMatch(filePath, rule)) {
+        return true;
+      }
+    } else if (rule instanceof RegExp) {
+      if (rule.test(filePath)) return true;
+    }
+  }
+  return false;
+}
+var AssetRevisioner = class {
+  options;
+  manifest = {};
+  constructor(options = {}) {
+    this.options = {
+      fileNameManifest: "rev-manifest.json",
+      dontRenameFile: [".html"],
+      dontUpdateReference: [],
+      hashLength: 8,
+      ...options
+    };
+  }
+  process(files) {
+    const hashLength = this.options.hashLength || 8;
+    const outputFiles = [];
+    for (const file2 of files) {
+      const origRelative = file2.relative;
+      file2.revPathOriginal = file2.path;
+      const shouldRename = !matchesAny(file2.path, this.options.dontRenameFile) && !matchesAny(file2.relative, this.options.dontRenameFile);
+      if (shouldRename) {
+        const fileHash = file.hash(file2.contents, hashLength);
+        const dir = path19.dirname(file2.path);
+        const newFilename = `${file2.stem}.${fileHash}${file2.extname}`;
+        file2.path = path19.join(dir, newFilename);
+      }
+      this.manifest[origRelative] = file2.relative;
+      outputFiles.push(file2);
+    }
+    for (const file2 of outputFiles) {
+      const shouldUpdate = !matchesAny(file2.path, this.options.dontUpdateReference) && !matchesAny(file2.relative, this.options.dontUpdateReference);
+      if (shouldUpdate && /\.(html|css|js)$/i.test(file2.extname)) {
+        let content = file2.toString();
+        for (const [orig, reved] of Object.entries(this.manifest)) {
+          if (orig !== reved) {
+            const origBase = path19.basename(orig);
+            const revedBase = path19.basename(reved);
+            content = content.replaceAll(origBase, revedBase);
+          }
+        }
+        file2.contents = Buffer.from(content);
+      }
+    }
+    const manifestName = this.options.fileNameManifest || "rev-manifest.json";
+    const firstBase = files[0]?.base || process.cwd();
+    const manifestFile = new VirtualFile({
+      cwd: files[0]?.cwd || process.cwd(),
+      base: firstBase,
+      path: path19.join(firstBase, manifestName),
+      contents: JSON.stringify(this.manifest, null, 2)
+    });
+    outputFiles.push(manifestFile);
+    return outputFiles;
+  }
+};
+
+// src/tasks/cache.ts
+var CacheTask = class extends BaseTask {
+  constructor() {
+    super({ name: "cache", description: "Revision assets and generate manifest" });
+  }
+  async run(config) {
+    const destDir = config.dest.base;
+    const filesToRev = await fg3(["**/*"], {
+      cwd: destDir,
+      absolute: true,
+      onlyFiles: true
+    });
+    if (!filesToRev.length) {
+      logger.warn("cache", "No files found to cache");
+      return;
+    }
+    const virtualFiles = await Promise.all(
+      filesToRev.map(async (filePath) => {
+        const buffer = await fs4.readFile(filePath);
+        return new VirtualFile({
+          cwd: config.workspace,
+          base: destDir,
+          path: filePath,
+          contents: buffer
+        });
+      })
+    );
+    const revisioner = new AssetRevisioner(config.assets.options);
+    const resultFiles = revisioner.process(virtualFiles);
+    for (const vFile of resultFiles) {
+      if (vFile.revPathOriginal && vFile.revPathOriginal !== vFile.path) {
+        await file.remove(vFile.revPathOriginal);
+      }
+    }
+    for (const vFile of resultFiles) {
+      await file.writeFile(vFile.path, vFile.contents);
+    }
+    logger.success("cache", "Asset revisioning and rev-manifest.json completed");
+  }
+};
+
+// src/tasks/publish.ts
+import path20 from "path";
+var PublishTask = class extends BaseTask {
+  options;
+  constructor(options = {}) {
+    super({ name: "publish", description: "Publish assets or templates" });
+    this.options = options;
+  }
+  async run(config) {
+    if (!config.env.isProd) {
+      logger.warn("publish", "`mix.publish()` is only supported in production mode");
+      return;
+    }
+    const { input, output, renameOptions } = this.options;
+    if (Array.isArray(input)) {
+      for (const item of input) {
+        await this.publishItem(config, item.input, item.output, item.renameOptions);
+      }
+    } else if (typeof input === "string" && output) {
+      await this.publishItem(config, input, output, renameOptions);
+    } else {
+      const srcDir = config.dest.base;
+      const targetDir = config.assets.static || path20.join(config.assets.root, config.assets.mainDir);
+      const pipeline = Pipeline.from(["**/*"], {
+        cwd: srcDir,
+        base: srcDir
+      });
+      await pipeline.dest(path20.resolve(config.workspace, targetDir));
+    }
+  }
+  async publishItem(config, input, output, rename) {
+    const srcPath = path20.isAbsolute(input) ? input : path20.join(config.dest.base, input);
+    const destDir = path20.isAbsolute(output) ? output : path20.join(config.workspace, config.assets.root, output);
+    const pipeline = Pipeline.from(srcPath, {
+      cwd: config.dest.base
+    });
+    if (rename) {
+      pipeline.pipe(transformRename(rename));
+    }
+    await pipeline.dest(destDir);
+  }
+};
+
+// src/tasks/pwa.ts
+import path21 from "path";
+import { generateSW, injectManifest } from "workbox-build";
+var PwaTask = class extends BaseTask {
+  options;
+  constructor(options = {}) {
+    super({ name: "pwa", description: "Generate Progressive Web App Service Worker" });
+    this.options = options;
+  }
+  async run(config) {
+    const mode = this.options.mode || config.pwa.mode || "generateSW";
+    const globDirectory = config.dest.base;
+    const swDest = path21.join(globDirectory, config.pwa.swDestFilename);
+    const swSrc = path21.join(config.src.base, config.pwa.swSrcFilename);
+    const mergedOptions = {
+      globDirectory,
+      swDest,
+      ...config.pwa.options,
+      ...this.options.options
+    };
+    if (mode === "injectManifest") {
+      mergedOptions.swSrc = mergedOptions.swSrc || swSrc;
+    }
+    try {
+      if (mode === "generateSW") {
+        const { count, size } = await generateSW(mergedOptions);
+        logger.info("pwa", `Generated '${swDest}', precaching ${count} files (${size} bytes)`);
+      } else {
+        const { count, size } = await injectManifest(mergedOptions);
+        logger.info("pwa", `Injected manifest into '${swDest}', precaching ${count} files (${size} bytes)`);
+      }
+    } catch (err) {
+      logger.warn("pwa", `Service worker generation failed: ${err.message || err}`);
+    }
+  }
+};
+
+// src/tasks/zip.ts
+import fs5 from "fs";
+import path22 from "path";
+import archiver from "archiver";
+var ZipTask = class extends BaseTask {
+  options;
+  constructor(options = {}) {
+    super({ name: "zip", description: "Compress files into archive" });
+    this.options = options;
+  }
+  async run(config) {
+    const input = this.options.input || config.dest.base;
+    const outputDir = this.options.output ? path22.isAbsolute(this.options.output) ? this.options.output : path22.join(config.workspace, this.options.output) : config.workspace;
+    const filename = this.options.filename || "archive.zip";
+    const zipPath = path22.join(outputDir, filename);
+    await file.ensureDir(outputDir);
+    return new Promise((resolve, reject) => {
+      const outputStream = fs5.createWriteStream(zipPath);
+      const archive = archiver("zip", { zlib: { level: 9 } });
+      outputStream.on("close", () => {
+        logger.success("zip", `Created ${zipPath} (${archive.pointer()} total bytes)`);
+        resolve();
+      });
+      archive.on("error", (err) => {
+        logger.error("zip", err.message);
+        reject(err);
+      });
+      archive.pipe(outputStream);
+      const inputs = Array.isArray(input) ? input : [input];
+      for (const item of inputs) {
+        const fullPath = path22.isAbsolute(item) ? item : path22.join(config.workspace, item);
+        if (fs5.existsSync(fullPath)) {
+          const stat = fs5.statSync(fullPath);
+          if (stat.isDirectory()) {
+            archive.directory(fullPath, false);
+          } else {
+            archive.file(fullPath, { name: path22.basename(fullPath) });
+          }
+        }
+      }
+      archive.finalize();
+    });
+  }
+};
+
+// src/tasks/ftp.ts
+import path23 from "path";
+import { Client } from "ssh2";
+import fg4 from "fast-glob";
+var FtpTask = class extends BaseTask {
+  ftpOptions;
+  constructor(ftpOptions = {}) {
+    super({ name: "ftp", description: "Upload files via SFTP" });
+    this.ftpOptions = ftpOptions;
+  }
+  async run(config) {
+    const options = {
+      port: 22,
+      remotePath: "/",
+      ...config.ftp.options,
+      ...this.ftpOptions.options
+    };
+    if (!options.host) {
+      logger.error("ftp", "`host` required for SFTP");
+      return;
+    }
+    const localFiles = this.ftpOptions.localFiles || config.dest.base;
+    const files = await fg4(localFiles, { cwd: config.workspace, absolute: true, onlyFiles: true });
+    if (!files.length) {
+      logger.warn("ftp", "No files to upload");
+      return;
+    }
+    return new Promise((resolve, reject) => {
+      const conn = new Client();
+      conn.on("ready", () => {
+        conn.sftp((err, sftp) => {
+          if (err) {
+            conn.end();
+            return reject(err);
+          }
+          let pending = files.length;
+          for (const file2 of files) {
+            const rel = path23.relative(config.workspace, file2);
+            const remoteFile = path23.posix.join(options.remotePath, rel);
+            sftp.fastPut(file2, remoteFile, (putErr) => {
+              if (putErr) {
+                logger.error("ftp", `Failed uploading ${file2}: ${putErr.message}`);
+              } else {
+                logger.info("ftp", `Uploaded ${file2} -> ${remoteFile}`);
+              }
+              pending--;
+              if (pending === 0) {
+                conn.end();
+                resolve();
+              }
+            });
+          }
+        });
+      });
+      conn.on("error", (connErr) => {
+        logger.error("ftp", connErr.message);
+        reject(connErr);
+      });
+      conn.connect(options);
+    });
+  }
+};
+
+// src/tasks/server.ts
+import http from "http";
+import connect from "connect";
+import serveStatic from "serve-static";
+import { WebSocketServer, WebSocket } from "ws";
+import { createProxyMiddleware } from "http-proxy-middleware";
+
+// src/watcher/index.ts
+import fs6 from "fs";
+import pc3 from "picocolors";
+var FileWatcher = class {
+  config;
+  broadcast;
+  debounceTimer = null;
+  pendingFiles = /* @__PURE__ */ new Set();
+  styleTask;
+  scriptTask;
+  htmlTask;
+  watcher = null;
+  constructor(config, broadcast) {
+    this.config = config;
+    this.broadcast = broadcast;
+    this.styleTask = new StyleTask();
+    this.scriptTask = new ScriptTask();
+    this.htmlTask = new HtmlTask();
+  }
+  start() {
+    const watchDir = this.config.src.base;
+    if (!fs6.existsSync(watchDir)) return;
+    logger.info("watch", `Watching for file changes in ${pc3.cyan(watchDir)}`);
+    try {
+      this.watcher = fs6.watch(watchDir, { recursive: true }, (eventType, filename) => {
+        if (!filename) return;
+        this.pendingFiles.add(filename);
+        if (this.debounceTimer) clearTimeout(this.debounceTimer);
+        this.debounceTimer = setTimeout(() => {
+          this.handleChanges();
+        }, 50);
+      });
+    } catch (err) {
+      logger.warn("watch", `Native recursive watch failed: ${err.message}`);
+    }
+  }
+  async handleChanges() {
+    const changed = Array.from(this.pendingFiles);
+    this.pendingFiles.clear();
+    const hasStyle = changed.some((f) => /\.(scss|sass|less|css)$/i.test(f));
+    const hasScript = changed.some((f) => /\.(js|mjs|cjs|ts|jsx|tsx)$/i.test(f));
+    const hasHtml = changed.some((f) => /\.html$/i.test(f));
+    try {
+      if (hasStyle) {
+        const start = performance.now();
+        await this.styleTask.run(this.config);
+        const duration = (performance.now() - start).toFixed(1);
+        logger.info("watch", `Recompiled styles in ${pc3.bold(duration + "ms")}`);
+        this.broadcast({ type: "reload-css" });
+      }
+      if (hasScript) {
+        const start = performance.now();
+        await this.scriptTask.run(this.config);
+        const duration = (performance.now() - start).toFixed(1);
+        logger.info("watch", `Rebundled scripts in ${pc3.bold(duration + "ms")}`);
+        this.broadcast({ type: "reload" });
+      }
+      if (hasHtml) {
+        const start = performance.now();
+        await this.htmlTask.run(this.config);
+        const duration = (performance.now() - start).toFixed(1);
+        logger.info("watch", `Recompiled HTML in ${pc3.bold(duration + "ms")}`);
+        this.broadcast({ type: "reload" });
+      }
+      if (!hasStyle && !hasScript && !hasHtml && changed.length > 0) {
+        this.broadcast({ type: "reload" });
+      }
+    } catch (err) {
+      logger.error("watch", `Incremental rebuild failed: ${err?.message || err}`);
+    }
+  }
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+  }
+};
+
+// src/tasks/server.ts
+import pc4 from "picocolors";
+var ServerTask = class extends BaseTask {
+  watcher = null;
+  wsServer = null;
+  clients = /* @__PURE__ */ new Set();
+  constructor() {
+    super({ name: "serve", description: "Start development server with live reload" });
+  }
+  broadcast(data) {
+    const payload = JSON.stringify(data);
+    for (const client of this.clients) {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(payload);
+      }
+    }
+  }
+  async run(config) {
+    if (config.env.isProd) {
+      logger.warn("server", "Development server is disabled in production mode");
+      return;
+    }
+    const app = connect();
+    const port = config.server.port || 3e3;
+    const host = config.server.host || "localhost";
+    app.use(serveStatic(config.dest.base));
+    app.use(serveStatic(config.src.base));
+    if (config.server.proxy && typeof config.server.proxy === "object") {
+      const proxyEntries = Array.isArray(config.server.proxy) ? config.server.proxy : [config.server.proxy];
+      for (const entry of proxyEntries) {
+        if (entry.context && entry.options) {
+          app.use(createProxyMiddleware(entry.options));
+        }
+      }
+    }
+    const server = http.createServer(app);
+    this.wsServer = new WebSocketServer({ server, path: "/__balm_ws" });
+    this.wsServer.on("connection", (socket) => {
+      this.clients.add(socket);
+      socket.on("close", () => this.clients.delete(socket));
+    });
+    this.watcher = new FileWatcher(config, (data) => {
+      this.broadcast(data);
+    });
+    this.watcher.start();
+    return new Promise((resolve) => {
+      server.listen(port, host, () => {
+        console.log("");
+        logger.success("server", pc4.bold("BalmJS Dev Server is ready!"));
+        console.log(`  ${pc4.green("\u279C")}  ${pc4.bold("Local:")}   ${pc4.cyan(`http://${host}:${port}/`)}`);
+        console.log(`  ${pc4.green("\u279C")}  ${pc4.bold("Network:")} ${pc4.cyan(`http://127.0.0.1:${port}/`)}`);
+        console.log("");
+        if (config.env.isTest) {
+          this.watcher?.stop();
+          this.wsServer?.close();
+          server.close();
+          resolve();
+        }
+      });
+    });
+  }
+};
+
+// src/hooks/index.ts
+var BalmHooks = class {
+  dag;
+  recipeIndex = 0;
+  constructor(dag) {
+    this.dag = dag;
+  }
+  addRecipeTask(fn) {
+    this.recipeIndex++;
+    const taskName = `recipe:${this.recipeIndex}`;
+    this.dag.registerTask(new FunctionTask(taskName, fn));
+  }
+  copy(input, output, options = {}) {
+    this.addRecipeTask(async (config) => {
+      const task = new CopyTask({ input, output, rename: options.rename });
+      await task.run(config);
+    });
+    return this;
+  }
+  remove(target) {
+    this.addRecipeTask(async (config) => {
+      const task = new RemoveTask(target);
+      await task.run(config);
+    });
+    return this;
+  }
+  replace(input, output, options) {
+    this.addRecipeTask(async (config) => {
+      const task = new ReplaceTask({ input, output, options });
+      await task.run(config);
+    });
+    return this;
+  }
+  sass(input, output, options = {}) {
+    this.addRecipeTask(async (config) => {
+      const pipeline = Pipeline.from(input, { cwd: config.workspace });
+      pipeline.pipe(transformSass(options));
+      pipeline.pipe(transformPostcss({ minify: config.env.isProd }));
+      await pipeline.dest(output);
+    });
+    return this;
+  }
+  less(input, output, options = {}) {
+    this.addRecipeTask(async (config) => {
+      const pipeline = Pipeline.from(input, { cwd: config.workspace });
+      pipeline.pipe(transformLess(options));
+      pipeline.pipe(transformPostcss({ minify: config.env.isProd }));
+      await pipeline.dest(output);
+    });
+    return this;
+  }
+  css(input, output, options = {}) {
+    this.addRecipeTask(async (config) => {
+      const pipeline = Pipeline.from(input, { cwd: config.workspace });
+      pipeline.pipe(transformPostcss({ minify: config.env.isProd, ...options }));
+      await pipeline.dest(output);
+    });
+    return this;
+  }
+  webpack(entry, output, customOptions = {}) {
+    this.addRecipeTask(async (config) => {
+      await runWebpack(config, {
+        ...entry ? { entry } : {},
+        ...output ? { output: { path: output } } : {},
+        ...customOptions
+      });
+    });
+    return this;
+  }
+  rollup(input, output, customInputOptions = {}, customOutputOptions = {}) {
+    this.addRecipeTask(async (config) => {
+      await runRollup(
+        config,
+        { ...input ? { input } : {}, ...customInputOptions },
+        { ...output ? { dir: output } : {}, ...customOutputOptions }
+      );
+    });
+    return this;
+  }
+  esbuild(entryPoints, outdir, customOptions = {}) {
+    this.addRecipeTask(async (config) => {
+      await runEsbuild(config, {
+        ...entryPoints ? { entryPoints } : {},
+        ...outdir ? { outdir } : {},
+        ...customOptions
+      });
+    });
+    return this;
+  }
+  js(input, output, options = {}) {
+    logger.warn("balm api", "`mix.js` is deprecated, please use `mix.webpack`/`mix.rollup`/`mix.esbuild` instead.");
+    return this.webpack(input, output, options);
+  }
+  publish(input, output, renameOptions) {
+    this.addRecipeTask(async (config) => {
+      const task = new PublishTask({ input, output, renameOptions });
+      await task.run(config);
+    });
+    return this;
+  }
+  generateSW(options = {}) {
+    this.addRecipeTask(async (config) => {
+      const task = new PwaTask({ mode: "generateSW", options });
+      await task.run(config);
+    });
+    return this;
+  }
+  injectManifest(options = {}) {
+    this.addRecipeTask(async (config) => {
+      const task = new PwaTask({ mode: "injectManifest", options });
+      await task.run(config);
+    });
+    return this;
+  }
+  ftp(localFiles, options = {}) {
+    this.addRecipeTask(async (config) => {
+      const task = new FtpTask({ localFiles, options });
+      await task.run(config);
+    });
+    return this;
+  }
+  zip(input, output, filename) {
+    this.addRecipeTask(async (config) => {
+      const task = new ZipTask({ input, output, filename });
+      await task.run(config);
+    });
+    return this;
+  }
+  serve() {
+    this.addRecipeTask(async (config) => {
+      const task = new ServerTask();
+      await task.run(config);
+    });
+    return this;
+  }
+};
+
+// src/balm.ts
+var Balm = class {
+  _config;
+  dag = new TaskDAG();
+  beforeTask;
+  afterTask;
+  Bundler = BundlerType;
+  constructor() {
+    this._config = resolveConfig();
+  }
+  get config() {
+    return this._config;
+  }
+  set config(customConfig) {
+    this._config = resolveConfig(customConfig);
+    if (this._config.logs?.level !== void 0) {
+      logger.level = this._config.logs.level;
+    }
+  }
+  async go(recipe) {
+    const endTimer = logger.time("Build");
+    const taskSequence = [];
+    this.dag.registerTask(new CleanTask());
+    this.dag.registerTask(new StyleTask());
+    this.dag.registerTask(new ScriptTask());
+    this.dag.registerTask(new HtmlTask());
+    this.dag.registerTask(new CacheTask());
+    this.dag.registerTask(new PwaTask());
+    this.dag.registerTask(new ServerTask());
+    if (typeof recipe === "function") {
+      const hooks = new BalmHooks(this.dag);
+      recipe(hooks);
+    }
+    if (this._config.useDefaults) {
+      taskSequence.push("clean", "style", "script", "html");
+      if (this._config.env.isProd) {
+        if (this._config.assets.cache) {
+          taskSequence.push("cache");
+        }
+        if (this._config.pwa.enabled) {
+          taskSequence.push("pwa");
+        }
+      } else {
+        taskSequence.push("serve");
+      }
+    }
+    try {
+      if (this.beforeTask) {
+        await this.beforeTask();
+      }
+      await this.dag.runSeries(taskSequence, this._config);
+      for (let i = 1; ; i++) {
+        const recipeName = `recipe:${i}`;
+        if (!this.dag.hasTask(recipeName)) break;
+        await this.dag.executeTask(recipeName, this._config);
+      }
+      if (this.afterTask) {
+        await this.afterTask();
+      }
+      endTimer();
+    } catch (err) {
+      logger.error("build", `Build failed: ${err?.message || err}`);
+      throw err;
+    }
+  }
+  reset() {
+    this.dag.clear();
+    this.beforeTask = void 0;
+    this.afterTask = void 0;
+    this._config = resolveConfig();
+  }
+};
+var balm = new Balm();
+
+// src/pipeline/transforms/terser.ts
+import { minify as minify2 } from "terser";
+function transformTerser(options = {}) {
+  return async (file2) => {
+    if (!/\.js$/i.test(file2.extname)) return file2;
+    try {
+      const result = await minify2(file2.toString(), options);
+      if (result.code) {
+        file2.contents = Buffer.from(result.code);
+      }
+      return file2;
+    } catch (err) {
+      logger.error("terser", `Error minifying ${file2.path}: ${err.message}`);
+      throw err;
+    }
+  };
+}
+
+// src/index.ts
+var index_default = balm;
+export {
+  ASSET,
+  ASSETS_TYPES,
+  ASSET_EXT,
+  AssetRevisioner,
+  Balm,
+  BalmHooks,
+  BaseTask,
+  BundlerType,
+  CHUNK,
+  CacheTask,
+  CleanTask,
+  CopyTask,
+  FileSystem,
+  FtpTask,
+  FunctionTask,
+  HtmlTask,
+  LogLevel,
+  PUBLIC_URL,
+  Pipeline,
+  PublishTask,
+  PwaTask,
+  RemoveTask,
+  ReplaceTask,
+  ScriptTask,
+  ServerTask,
+  StyleTask,
+  TaskDAG,
+  VirtualFile,
+  ZipTask,
+  balm,
+  createDefaultConfig,
+  deepMerge,
+  index_default as default,
+  file,
+  getWorkspaces,
+  globalResolve,
+  globalWorkspace,
+  isArray,
+  isBoolean,
+  isFunction,
+  isObject,
+  isString,
+  localResolve,
+  localWorkspace,
+  logger,
+  resolveConfig,
+  runEsbuild,
+  runRollup,
+  runWebpack,
+  setWorkspaces,
+  toNamespace,
+  transformHtmlmin,
+  transformLess,
+  transformPostcss,
+  transformRename,
+  transformReplace,
+  transformSass,
+  transformTerser
+};
+//# sourceMappingURL=index.js.map