difflens 0.0.1

package/dist/cli.js

@@ -0,0 +1,1173 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/reporters/ai-reporter.ts
+var ai_reporter_exports = {};
+__export(ai_reporter_exports, {
+  formatAiReport: () => formatAiReport
+});
+function formatAiReport(results, outDir) {
+  let output = "DiffLens Test Report\n====================\n\n";
+  const failures = results.filter((r) => r.status === "fail" || r.a11yViolations.length > 0);
+  if (failures.length === 0) {
+    return output + "All tests passed. No visual regressions or accessibility violations found.\n";
+  }
+  output += `Found ${failures.length} issues:
+
+`;
+  failures.forEach((result, index) => {
+    output += `Issue #${index + 1}: ${result.scenario}
+`;
+    output += `----------------------------------------
+`;
+    if (result.status === "fail") {
+      if (result.dimensionMismatch) {
+        output += `[Dimension Mismatch]
+`;
+        output += `  Baseline and current images have different dimensions.
+`;
+      } else if (result.diffPixels > 0) {
+        output += `[Visual Regression]
+`;
+        output += `  Diff Pixels: ${result.diffPixels} (${result.diffPercentage.toFixed(2)}%)
+`;
+        if (result.diffPath) {
+          output += `  Diff Image: ${import_path3.default.relative(process.cwd(), result.diffPath)}
+`;
+        }
+      }
+    }
+    if (result.a11yViolations.length > 0) {
+      output += `[Accessibility Violations]
+`;
+      result.a11yViolations.forEach((v) => {
+        output += `  - [${v.impact}] ${v.help} (${v.id})
+`;
+        output += `    Target: ${v.nodes.map((n) => n.target.join(", ")).join(" | ")}
+`;
+      });
+    }
+    output += "\n";
+  });
+  return output;
+}
+var import_path3;
+var init_ai_reporter = __esm({
+  "src/core/reporters/ai-reporter.ts"() {
+    "use strict";
+    import_path3 = __toESM(require("path"));
+  }
+});
+
+// node_modules/cac/dist/index.mjs
+var import_events = require("events");
+function toArr(any) {
+  return any == null ? [] : Array.isArray(any) ? any : [any];
+}
+function toVal(out, key, val, opts) {
+  var x, old = out[key], nxt = !!~opts.string.indexOf(key) ? val == null || val === true ? "" : String(val) : typeof val === "boolean" ? val : !!~opts.boolean.indexOf(key) ? val === "false" ? false : val === "true" || (out._.push((x = +val, x * 0 === 0) ? x : val), !!val) : (x = +val, x * 0 === 0) ? x : val;
+  out[key] = old == null ? nxt : Array.isArray(old) ? old.concat(nxt) : [old, nxt];
+}
+function mri2(args, opts) {
+  args = args || [];
+  opts = opts || {};
+  var k, arr, arg, name, val, out = { _: [] };
+  var i = 0, j = 0, idx = 0, len = args.length;
+  const alibi = opts.alias !== void 0;
+  const strict = opts.unknown !== void 0;
+  const defaults = opts.default !== void 0;
+  opts.alias = opts.alias || {};
+  opts.string = toArr(opts.string);
+  opts.boolean = toArr(opts.boolean);
+  if (alibi) {
+    for (k in opts.alias) {
+      arr = opts.alias[k] = toArr(opts.alias[k]);
+      for (i = 0; i < arr.length; i++) {
+        (opts.alias[arr[i]] = arr.concat(k)).splice(i, 1);
+      }
+    }
+  }
+  for (i = opts.boolean.length; i-- > 0; ) {
+    arr = opts.alias[opts.boolean[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.boolean.push(arr[j]);
+  }
+  for (i = opts.string.length; i-- > 0; ) {
+    arr = opts.alias[opts.string[i]] || [];
+    for (j = arr.length; j-- > 0; ) opts.string.push(arr[j]);
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      name = typeof opts.default[k];
+      arr = opts.alias[k] = opts.alias[k] || [];
+      if (opts[name] !== void 0) {
+        opts[name].push(k);
+        for (i = 0; i < arr.length; i++) {
+          opts[name].push(arr[i]);
+        }
+      }
+    }
+  }
+  const keys = strict ? Object.keys(opts.alias) : [];
+  for (i = 0; i < len; i++) {
+    arg = args[i];
+    if (arg === "--") {
+      out._ = out._.concat(args.slice(++i));
+      break;
+    }
+    for (j = 0; j < arg.length; j++) {
+      if (arg.charCodeAt(j) !== 45) break;
+    }
+    if (j === 0) {
+      out._.push(arg);
+    } else if (arg.substring(j, j + 3) === "no-") {
+      name = arg.substring(j + 3);
+      if (strict && !~keys.indexOf(name)) {
+        return opts.unknown(arg);
+      }
+      out[name] = false;
+    } else {
+      for (idx = j + 1; idx < arg.length; idx++) {
+        if (arg.charCodeAt(idx) === 61) break;
+      }
+      name = arg.substring(j, idx);
+      val = arg.substring(++idx) || (i + 1 === len || ("" + args[i + 1]).charCodeAt(0) === 45 || args[++i]);
+      arr = j === 2 ? [name] : name;
+      for (idx = 0; idx < arr.length; idx++) {
+        name = arr[idx];
+        if (strict && !~keys.indexOf(name)) return opts.unknown("-".repeat(j) + name);
+        toVal(out, name, idx + 1 < arr.length || val, opts);
+      }
+    }
+  }
+  if (defaults) {
+    for (k in opts.default) {
+      if (out[k] === void 0) {
+        out[k] = opts.default[k];
+      }
+    }
+  }
+  if (alibi) {
+    for (k in out) {
+      arr = opts.alias[k] || [];
+      while (arr.length > 0) {
+        out[arr.shift()] = out[k];
+      }
+    }
+  }
+  return out;
+}
+var removeBrackets = (v) => v.replace(/[<[].+/, "").trim();
+var findAllBrackets = (v) => {
+  const ANGLED_BRACKET_RE_GLOBAL = /<([^>]+)>/g;
+  const SQUARE_BRACKET_RE_GLOBAL = /\[([^\]]+)\]/g;
+  const res = [];
+  const parse = (match) => {
+    let variadic = false;
+    let value = match[1];
+    if (value.startsWith("...")) {
+      value = value.slice(3);
+      variadic = true;
+    }
+    return {
+      required: match[0].startsWith("<"),
+      value,
+      variadic
+    };
+  };
+  let angledMatch;
+  while (angledMatch = ANGLED_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(angledMatch));
+  }
+  let squareMatch;
+  while (squareMatch = SQUARE_BRACKET_RE_GLOBAL.exec(v)) {
+    res.push(parse(squareMatch));
+  }
+  return res;
+};
+var getMriOptions = (options) => {
+  const result = { alias: {}, boolean: [] };
+  for (const [index, option] of options.entries()) {
+    if (option.names.length > 1) {
+      result.alias[option.names[0]] = option.names.slice(1);
+    }
+    if (option.isBoolean) {
+      if (option.negated) {
+        const hasStringTypeOption = options.some((o, i) => {
+          return i !== index && o.names.some((name) => option.names.includes(name)) && typeof o.required === "boolean";
+        });
+        if (!hasStringTypeOption) {
+          result.boolean.push(option.names[0]);
+        }
+      } else {
+        result.boolean.push(option.names[0]);
+      }
+    }
+  }
+  return result;
+};
+var findLongest = (arr) => {
+  return arr.sort((a, b) => {
+    return a.length > b.length ? -1 : 1;
+  })[0];
+};
+var padRight = (str, length) => {
+  return str.length >= length ? str : `${str}${" ".repeat(length - str.length)}`;
+};
+var camelcase = (input) => {
+  return input.replace(/([a-z])-([a-z])/g, (_, p1, p2) => {
+    return p1 + p2.toUpperCase();
+  });
+};
+var setDotProp = (obj, keys, val) => {
+  let i = 0;
+  let length = keys.length;
+  let t = obj;
+  let x;
+  for (; i < length; ++i) {
+    x = t[keys[i]];
+    t = t[keys[i]] = i === length - 1 ? val : x != null ? x : !!~keys[i + 1].indexOf(".") || !(+keys[i + 1] > -1) ? {} : [];
+  }
+};
+var setByType = (obj, transforms) => {
+  for (const key of Object.keys(transforms)) {
+    const transform = transforms[key];
+    if (transform.shouldTransform) {
+      obj[key] = Array.prototype.concat.call([], obj[key]);
+      if (typeof transform.transformFunction === "function") {
+        obj[key] = obj[key].map(transform.transformFunction);
+      }
+    }
+  }
+};
+var getFileName = (input) => {
+  const m = /([^\\\/]+)$/.exec(input);
+  return m ? m[1] : "";
+};
+var camelcaseOptionName = (name) => {
+  return name.split(".").map((v, i) => {
+    return i === 0 ? camelcase(v) : v;
+  }).join(".");
+};
+var CACError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+    if (typeof Error.captureStackTrace === "function") {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+  }
+};
+var Option = class {
+  constructor(rawName, description, config) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = Object.assign({}, config);
+    rawName = rawName.replace(/\.\*/g, "");
+    this.negated = false;
+    this.names = removeBrackets(rawName).split(",").map((v) => {
+      let name = v.trim().replace(/^-{1,2}/, "");
+      if (name.startsWith("no-")) {
+        this.negated = true;
+        name = name.replace(/^no-/, "");
+      }
+      return camelcaseOptionName(name);
+    }).sort((a, b) => a.length > b.length ? 1 : -1);
+    this.name = this.names[this.names.length - 1];
+    if (this.negated && this.config.default == null) {
+      this.config.default = true;
+    }
+    if (rawName.includes("<")) {
+      this.required = true;
+    } else if (rawName.includes("[")) {
+      this.required = false;
+    } else {
+      this.isBoolean = true;
+    }
+  }
+};
+var processArgs = process.argv;
+var platformInfo = `${process.platform}-${process.arch} node-${process.version}`;
+var Command = class {
+  constructor(rawName, description, config = {}, cli2) {
+    this.rawName = rawName;
+    this.description = description;
+    this.config = config;
+    this.cli = cli2;
+    this.options = [];
+    this.aliasNames = [];
+    this.name = removeBrackets(rawName);
+    this.args = findAllBrackets(rawName);
+    this.examples = [];
+  }
+  usage(text) {
+    this.usageText = text;
+    return this;
+  }
+  allowUnknownOptions() {
+    this.config.allowUnknownOptions = true;
+    return this;
+  }
+  ignoreOptionDefaultValue() {
+    this.config.ignoreOptionDefaultValue = true;
+    return this;
+  }
+  version(version2, customFlags = "-v, --version") {
+    this.versionNumber = version2;
+    this.option(customFlags, "Display version number");
+    return this;
+  }
+  example(example) {
+    this.examples.push(example);
+    return this;
+  }
+  option(rawName, description, config) {
+    const option = new Option(rawName, description, config);
+    this.options.push(option);
+    return this;
+  }
+  alias(name) {
+    this.aliasNames.push(name);
+    return this;
+  }
+  action(callback) {
+    this.commandAction = callback;
+    return this;
+  }
+  isMatched(name) {
+    return this.name === name || this.aliasNames.includes(name);
+  }
+  get isDefaultCommand() {
+    return this.name === "" || this.aliasNames.includes("!");
+  }
+  get isGlobalCommand() {
+    return this instanceof GlobalCommand;
+  }
+  hasOption(name) {
+    name = name.split(".")[0];
+    return this.options.find((option) => {
+      return option.names.includes(name);
+    });
+  }
+  outputHelp() {
+    const { name, commands } = this.cli;
+    const {
+      versionNumber,
+      options: globalOptions,
+      helpCallback
+    } = this.cli.globalCommand;
+    let sections = [
+      {
+        body: `${name}${versionNumber ? `/${versionNumber}` : ""}`
+      }
+    ];
+    sections.push({
+      title: "Usage",
+      body: `  $ ${name} ${this.usageText || this.rawName}`
+    });
+    const showCommands = (this.isGlobalCommand || this.isDefaultCommand) && commands.length > 0;
+    if (showCommands) {
+      const longestCommandName = findLongest(commands.map((command) => command.rawName));
+      sections.push({
+        title: "Commands",
+        body: commands.map((command) => {
+          return `  ${padRight(command.rawName, longestCommandName.length)}  ${command.description}`;
+        }).join("\n")
+      });
+      sections.push({
+        title: `For more info, run any command with the \`--help\` flag`,
+        body: commands.map((command) => `  $ ${name}${command.name === "" ? "" : ` ${command.name}`} --help`).join("\n")
+      });
+    }
+    let options = this.isGlobalCommand ? globalOptions : [...this.options, ...globalOptions || []];
+    if (!this.isGlobalCommand && !this.isDefaultCommand) {
+      options = options.filter((option) => option.name !== "version");
+    }
+    if (options.length > 0) {
+      const longestOptionName = findLongest(options.map((option) => option.rawName));
+      sections.push({
+        title: "Options",
+        body: options.map((option) => {
+          return `  ${padRight(option.rawName, longestOptionName.length)}  ${option.description} ${option.config.default === void 0 ? "" : `(default: ${option.config.default})`}`;
+        }).join("\n")
+      });
+    }
+    if (this.examples.length > 0) {
+      sections.push({
+        title: "Examples",
+        body: this.examples.map((example) => {
+          if (typeof example === "function") {
+            return example(name);
+          }
+          return example;
+        }).join("\n")
+      });
+    }
+    if (helpCallback) {
+      sections = helpCallback(sections) || sections;
+    }
+    console.log(sections.map((section) => {
+      return section.title ? `${section.title}:
+${section.body}` : section.body;
+    }).join("\n\n"));
+  }
+  outputVersion() {
+    const { name } = this.cli;
+    const { versionNumber } = this.cli.globalCommand;
+    if (versionNumber) {
+      console.log(`${name}/${versionNumber} ${platformInfo}`);
+    }
+  }
+  checkRequiredArgs() {
+    const minimalArgsCount = this.args.filter((arg) => arg.required).length;
+    if (this.cli.args.length < minimalArgsCount) {
+      throw new CACError(`missing required args for command \`${this.rawName}\``);
+    }
+  }
+  checkUnknownOptions() {
+    const { options, globalCommand } = this.cli;
+    if (!this.config.allowUnknownOptions) {
+      for (const name of Object.keys(options)) {
+        if (name !== "--" && !this.hasOption(name) && !globalCommand.hasOption(name)) {
+          throw new CACError(`Unknown option \`${name.length > 1 ? `--${name}` : `-${name}`}\``);
+        }
+      }
+    }
+  }
+  checkOptionValue() {
+    const { options: parsedOptions, globalCommand } = this.cli;
+    const options = [...globalCommand.options, ...this.options];
+    for (const option of options) {
+      const value = parsedOptions[option.name.split(".")[0]];
+      if (option.required) {
+        const hasNegated = options.some((o) => o.negated && o.names.includes(option.name));
+        if (value === true || value === false && !hasNegated) {
+          throw new CACError(`option \`${option.rawName}\` value is missing`);
+        }
+      }
+    }
+  }
+};
+var GlobalCommand = class extends Command {
+  constructor(cli2) {
+    super("@@global@@", "", {}, cli2);
+  }
+};
+var __assign = Object.assign;
+var CAC = class extends import_events.EventEmitter {
+  constructor(name = "") {
+    super();
+    this.name = name;
+    this.commands = [];
+    this.rawArgs = [];
+    this.args = [];
+    this.options = {};
+    this.globalCommand = new GlobalCommand(this);
+    this.globalCommand.usage("<command> [options]");
+  }
+  usage(text) {
+    this.globalCommand.usage(text);
+    return this;
+  }
+  command(rawName, description, config) {
+    const command = new Command(rawName, description || "", config, this);
+    command.globalCommand = this.globalCommand;
+    this.commands.push(command);
+    return command;
+  }
+  option(rawName, description, config) {
+    this.globalCommand.option(rawName, description, config);
+    return this;
+  }
+  help(callback) {
+    this.globalCommand.option("-h, --help", "Display this message");
+    this.globalCommand.helpCallback = callback;
+    this.showHelpOnExit = true;
+    return this;
+  }
+  version(version2, customFlags = "-v, --version") {
+    this.globalCommand.version(version2, customFlags);
+    this.showVersionOnExit = true;
+    return this;
+  }
+  example(example) {
+    this.globalCommand.example(example);
+    return this;
+  }
+  outputHelp() {
+    if (this.matchedCommand) {
+      this.matchedCommand.outputHelp();
+    } else {
+      this.globalCommand.outputHelp();
+    }
+  }
+  outputVersion() {
+    this.globalCommand.outputVersion();
+  }
+  setParsedInfo({ args, options }, matchedCommand, matchedCommandName) {
+    this.args = args;
+    this.options = options;
+    if (matchedCommand) {
+      this.matchedCommand = matchedCommand;
+    }
+    if (matchedCommandName) {
+      this.matchedCommandName = matchedCommandName;
+    }
+    return this;
+  }
+  unsetMatchedCommand() {
+    this.matchedCommand = void 0;
+    this.matchedCommandName = void 0;
+  }
+  parse(argv = processArgs, {
+    run = true
+  } = {}) {
+    this.rawArgs = argv;
+    if (!this.name) {
+      this.name = argv[1] ? getFileName(argv[1]) : "cli";
+    }
+    let shouldParse = true;
+    for (const command of this.commands) {
+      const parsed = this.mri(argv.slice(2), command);
+      const commandName = parsed.args[0];
+      if (command.isMatched(commandName)) {
+        shouldParse = false;
+        const parsedInfo = __assign(__assign({}, parsed), {
+          args: parsed.args.slice(1)
+        });
+        this.setParsedInfo(parsedInfo, command, commandName);
+        this.emit(`command:${commandName}`, command);
+      }
+    }
+    if (shouldParse) {
+      for (const command of this.commands) {
+        if (command.name === "") {
+          shouldParse = false;
+          const parsed = this.mri(argv.slice(2), command);
+          this.setParsedInfo(parsed, command);
+          this.emit(`command:!`, command);
+        }
+      }
+    }
+    if (shouldParse) {
+      const parsed = this.mri(argv.slice(2));
+      this.setParsedInfo(parsed);
+    }
+    if (this.options.help && this.showHelpOnExit) {
+      this.outputHelp();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    if (this.options.version && this.showVersionOnExit && this.matchedCommandName == null) {
+      this.outputVersion();
+      run = false;
+      this.unsetMatchedCommand();
+    }
+    const parsedArgv = { args: this.args, options: this.options };
+    if (run) {
+      this.runMatchedCommand();
+    }
+    if (!this.matchedCommand && this.args[0]) {
+      this.emit("command:*");
+    }
+    return parsedArgv;
+  }
+  mri(argv, command) {
+    const cliOptions = [
+      ...this.globalCommand.options,
+      ...command ? command.options : []
+    ];
+    const mriOptions = getMriOptions(cliOptions);
+    let argsAfterDoubleDashes = [];
+    const doubleDashesIndex = argv.indexOf("--");
+    if (doubleDashesIndex > -1) {
+      argsAfterDoubleDashes = argv.slice(doubleDashesIndex + 1);
+      argv = argv.slice(0, doubleDashesIndex);
+    }
+    let parsed = mri2(argv, mriOptions);
+    parsed = Object.keys(parsed).reduce((res, name) => {
+      return __assign(__assign({}, res), {
+        [camelcaseOptionName(name)]: parsed[name]
+      });
+    }, { _: [] });
+    const args = parsed._;
+    const options = {
+      "--": argsAfterDoubleDashes
+    };
+    const ignoreDefault = command && command.config.ignoreOptionDefaultValue ? command.config.ignoreOptionDefaultValue : this.globalCommand.config.ignoreOptionDefaultValue;
+    let transforms = /* @__PURE__ */ Object.create(null);
+    for (const cliOption of cliOptions) {
+      if (!ignoreDefault && cliOption.config.default !== void 0) {
+        for (const name of cliOption.names) {
+          options[name] = cliOption.config.default;
+        }
+      }
+      if (Array.isArray(cliOption.config.type)) {
+        if (transforms[cliOption.name] === void 0) {
+          transforms[cliOption.name] = /* @__PURE__ */ Object.create(null);
+          transforms[cliOption.name]["shouldTransform"] = true;
+          transforms[cliOption.name]["transformFunction"] = cliOption.config.type[0];
+        }
+      }
+    }
+    for (const key of Object.keys(parsed)) {
+      if (key !== "_") {
+        const keys = key.split(".");
+        setDotProp(options, keys, parsed[key]);
+        setByType(options, transforms);
+      }
+    }
+    return {
+      args,
+      options
+    };
+  }
+  runMatchedCommand() {
+    const { args, options, matchedCommand: command } = this;
+    if (!command || !command.commandAction)
+      return;
+    command.checkUnknownOptions();
+    command.checkOptionValue();
+    command.checkRequiredArgs();
+    const actionArgs = [];
+    command.args.forEach((arg, index) => {
+      if (arg.variadic) {
+        actionArgs.push(args.slice(index));
+      } else {
+        actionArgs.push(args[index]);
+      }
+    });
+    actionArgs.push(options);
+    return command.commandAction.apply(this, actionArgs);
+  }
+};
+var cac = (name = "") => new CAC(name);
+var dist_default = cac;
+
+// src/cli.ts
+var import_fs5 = __toESM(require("fs"));
+var import_path5 = __toESM(require("path"));
+
+// package.json
+var version = "0.0.1";
+
+// src/config.ts
+var import_path = __toESM(require("path"));
+var import_fs = __toESM(require("fs"));
+var import_esbuild = require("esbuild");
+var DEFAULT_CONFIG = {
+  scenarios: [],
+  threshold: 0.1,
+  outDir: ".difflens"
+};
+async function loadConfig(configPath) {
+  const searchPlaces = [
+    "difflens.config.ts",
+    "difflens.config.js",
+    "difflens.config.mjs",
+    "difflens.config.cjs"
+  ];
+  let resolvedPath;
+  if (configPath) {
+    resolvedPath = import_path.default.resolve(process.cwd(), configPath);
+  } else {
+    for (const place of searchPlaces) {
+      const p = import_path.default.resolve(process.cwd(), place);
+      if (import_fs.default.existsSync(p)) {
+        resolvedPath = p;
+        break;
+      }
+    }
+  }
+  if (!resolvedPath) {
+    console.warn("No configuration file found. Using default config.");
+    return DEFAULT_CONFIG;
+  }
+  try {
+    let importPath = resolvedPath;
+    let isTs = resolvedPath.endsWith(".ts");
+    let tempFile = null;
+    if (isTs) {
+      const outfile = resolvedPath.replace(/\.ts$/, ".js.tmp.mjs");
+      await (0, import_esbuild.build)({
+        entryPoints: [resolvedPath],
+        outfile,
+        bundle: true,
+        platform: "node",
+        format: "esm",
+        external: ["difflens"]
+        // Exclude self if referenced?
+      });
+      importPath = outfile;
+      tempFile = outfile;
+    }
+    const importUrl = `file://${importPath}`;
+    const userConfigModule = await import(importUrl);
+    const userConfig = userConfigModule.default || userConfigModule;
+    if (tempFile && import_fs.default.existsSync(tempFile)) {
+      import_fs.default.unlinkSync(tempFile);
+    }
+    return {
+      ...DEFAULT_CONFIG,
+      ...userConfig
+    };
+  } catch (error) {
+    console.error(`Failed to load configuration from ${resolvedPath}:`, error);
+    throw error;
+  }
+}
+
+// src/core/runner.ts
+var import_playwright2 = require("playwright");
+var import_path4 = __toESM(require("path"));
+var import_fs4 = __toESM(require("fs"));
+
+// src/core/capture.ts
+async function captureScreenshot(page, url, outputPath, options = {}) {
+  if (url) {
+    await page.goto(url, { waitUntil: "networkidle" });
+  }
+  await page.evaluate(() => document.fonts.ready);
+  await page.addStyleTag({
+    content: `
+      *, *::before, *::after {
+        animation-duration: 0s !important;
+        transition-duration: 0s !important;
+        animation-iteration-count: 1 !important;
+      }
+    `
+  });
+  if (options.hideSelectors) {
+    for (const selector of options.hideSelectors) {
+      await page.locator(selector).evaluate((el) => el.style.visibility = "hidden");
+    }
+  }
+  if (options.maskSelectors) {
+    for (const selector of options.maskSelectors) {
+      await page.locator(selector).evaluate((el) => el.style.backgroundColor = "#FF00FF");
+    }
+  }
+  await page.screenshot({
+    path: outputPath,
+    fullPage: options.fullPage ?? true,
+    animations: "disabled"
+  });
+}
+
+// src/core/compare.ts
+var import_fs2 = __toESM(require("fs"));
+var import_pngjs = require("pngjs");
+var import_pixelmatch = __toESM(require("pixelmatch"));
+function compareImages(img1Path, img2Path, diffPath, threshold = 0.1) {
+  const img1 = import_pngjs.PNG.sync.read(import_fs2.default.readFileSync(img1Path));
+  const img2 = import_pngjs.PNG.sync.read(import_fs2.default.readFileSync(img2Path));
+  const { width, height } = img1;
+  const diff = new import_pngjs.PNG({ width, height });
+  if (img1.width !== img2.width || img1.height !== img2.height) {
+    return {
+      diffPixels: -1,
+      diffPercentage: -1,
+      isSameDimensions: false
+    };
+  }
+  const diffPixels = (0, import_pixelmatch.default)(
+    img1.data,
+    img2.data,
+    diff.data,
+    width,
+    height,
+    { threshold }
+  );
+  import_fs2.default.writeFileSync(diffPath, import_pngjs.PNG.sync.write(diff));
+  const totalPixels = width * height;
+  const diffPercentage = diffPixels / totalPixels * 100;
+  return {
+    diffPixels,
+    diffPercentage,
+    isSameDimensions: true
+  };
+}
+
+// src/core/a11y.ts
+var import_playwright = __toESM(require("@axe-core/playwright"));
+async function runAxeAudit(page) {
+  const results = await new import_playwright.default({ page }).analyze();
+  if (results.violations.length > 0) {
+    console.error(`Found ${results.violations.length} accessibility violations:`);
+    results.violations.forEach((violation) => {
+      console.error(`- [${violation.impact}] ${violation.help} (${violation.id})`);
+      violation.nodes.forEach((node) => {
+        console.error(`  Target: ${node.target}`);
+      });
+    });
+  }
+  return {
+    violations: results.violations
+  };
+}
+
+// src/core/report.ts
+var import_fs3 = __toESM(require("fs"));
+var import_path2 = __toESM(require("path"));
+function generateHtmlReport(data, outDir) {
+  const html = `
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>DiffLens Report</title>
+  <style>
+    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif; margin: 0; padding: 20px; background: #f5f5f5; }
+    .container { max-width: 1200px; margin: 0 auto; background: white; padding: 20px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
+    h1 { color: #333; border-bottom: 2px solid #eee; padding-bottom: 10px; }
+    .summary { margin-bottom: 20px; padding: 15px; background: #eef; border-radius: 4px; }
+    .scenario { border: 1px solid #ddd; margin-bottom: 20px; border-radius: 4px; overflow: hidden; }
+    .scenario-header { padding: 10px 15px; background: #f9f9f9; border-bottom: 1px solid #ddd; display: flex; justify-content: space-between; align-items: center; }
+    .scenario-title { font-weight: bold; font-size: 1.1em; }
+    .status { padding: 4px 8px; border-radius: 4px; font-size: 0.9em; font-weight: bold; color: white; }
+    .status.pass { background: #28a745; }
+    .status.fail { background: #dc3545; }
+    .status.new { background: #17a2b8; }
+    .scenario-body { padding: 15px; }
+    .images { display: flex; gap: 20px; margin-bottom: 15px; overflow-x: auto; }
+    .image-container { flex: 0 0 auto; }
+    .image-container img { max-width: 300px; border: 1px solid #ddd; border-radius: 4px; }
+    .image-label { font-size: 0.9em; color: #666; margin-bottom: 5px; }
+    .a11y { margin-top: 15px; border-top: 1px solid #eee; padding-top: 10px; }
+    .a11y-title { font-weight: bold; color: #666; margin-bottom: 5px; }
+    .violation { margin-bottom: 5px; color: #d63384; }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>DiffLens Report</h1>
+    <div class="summary">
+      <p><strong>Generated at:</strong> ${new Date(data.timestamp).toLocaleString()}</p>
+      <p><strong>Total Scenarios:</strong> ${data.results.length}</p>
+      <p><strong>Failed:</strong> ${data.results.filter((r) => r.status === "fail").length}</p>
+    </div>
+
+    ${data.results.map((result) => `
+      <div class="scenario">
+        <div class="scenario-header">
+          <span class="scenario-title">${result.scenario}</span>
+          <span class="status ${result.status}">${result.status.toUpperCase()}</span>
+        </div>
+        <div class="scenario-body">
+          <div class="images">
+            ${result.baselinePath ? `
+              <div class="image-container">
+                <div class="image-label">Baseline</div>
+                <img src="${import_path2.default.relative(import_path2.default.resolve(outDir), import_path2.default.resolve(result.baselinePath))}" alt="Baseline">
+              </div>
+            ` : ""}
+            <div class="image-container">
+              <div class="image-label">Current</div>
+              <img src="${import_path2.default.relative(import_path2.default.resolve(outDir), import_path2.default.resolve(result.screenshotPath))}" alt="Current">
+            </div>
+            ${result.diffPath ? `
+              <div class="image-container">
+                <div class="image-label">Diff</div>
+                <img src="${import_path2.default.relative(import_path2.default.resolve(outDir), import_path2.default.resolve(result.diffPath))}" alt="Diff">
+              </div>
+            ` : ""}
+          </div>
+          
+          ${result.diffPixels === -1 ? `
+            <p style="color: #dc3545; font-weight: bold;">[FAIL] Dimension mismatch! Baseline and current images have different sizes.</p>
+          ` : `
+            <p><strong>Diff:</strong> ${result.diffPixels} pixels (${result.diffPercentage.toFixed(2)}%)</p>
+          `}
+
+          ${result.a11yViolations.length > 0 ? `
+            <div class="a11y">
+              <div class="a11y-title">Accessibility Violations (${result.a11yViolations.length})</div>
+              ${result.a11yViolations.map((v) => `
+                <div class="violation">
+                  [${v.impact}] ${v.help} (${v.id})
+                </div>
+              `).join("")}
+            </div>
+          ` : '<div class="a11y"><div class="a11y-title">No Accessibility Violations</div></div>'}
+        </div>
+      </div>
+    `).join("")}
+  </div>
+</body>
+</html>
+  `;
+  import_fs3.default.writeFileSync(import_path2.default.join(outDir, "index.html"), html);
+  import_fs3.default.writeFileSync(import_path2.default.join(outDir, "report.json"), JSON.stringify(data, null, 2));
+  console.log(`Report generated: ${import_path2.default.join(outDir, "index.html")}`);
+}
+
+// src/core/runner.ts
+async function runTests(config) {
+  const browser = await import_playwright2.chromium.launch();
+  const context = await browser.newContext();
+  const page = await context.newPage();
+  const outDir = config.outDir || ".difflens";
+  const dirs = {
+    baseline: import_path4.default.join(outDir, "baseline"),
+    current: import_path4.default.join(outDir, "current"),
+    diff: import_path4.default.join(outDir, "diff")
+  };
+  Object.values(dirs).forEach((dir) => {
+    if (!import_fs4.default.existsSync(dir)) {
+      import_fs4.default.mkdirSync(dir, { recursive: true });
+    }
+  });
+  const results = [];
+  if (!config.scenarios || config.scenarios.length === 0) {
+    console.error("Error: No scenarios defined in configuration.");
+    return false;
+  }
+  for (const scenario of config.scenarios) {
+    const viewports = scenario.viewports || config.viewports && Object.entries(config.viewports).map(([label, { width, height }]) => ({ label, width, height })) || [{ width: 1280, height: 720, label: "default" }];
+    for (const viewport of viewports) {
+      const viewportLabel = viewport.label || `${viewport.width}x${viewport.height}`;
+      const label = viewports.length > 1 || viewport.label ? `${scenario.label}-${viewportLabel}` : scenario.label;
+      console.error(`Running scenario: ${label}`);
+      const url = config.baseUrl ? new URL(scenario.path, config.baseUrl).toString() : scenario.path;
+      await page.setViewportSize({ width: viewport.width, height: viewport.height });
+      let retries = 2;
+      let navigationSuccess = false;
+      while (retries >= 0) {
+        try {
+          await page.goto(url, { waitUntil: "networkidle" });
+          navigationSuccess = true;
+          break;
+        } catch (e) {
+          if (retries === 0) {
+            console.error(`  [WARN] Navigation failed: ${e}`);
+          } else {
+            console.error(`  [WARN] Navigation failed, retrying... (${retries} attempts left)`);
+            retries--;
+            await page.waitForTimeout(1e3);
+          }
+        }
+      }
+      if (!navigationSuccess) {
+        if (config.failOnNavigationError) {
+          console.error(`  [FAIL] Navigation failed.`);
+          results.push({
+            scenario: label,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+            status: "fail",
+            diffPixels: 0,
+            diffPercentage: 0,
+            screenshotPath: "",
+            a11yViolations: []
+          });
+          continue;
+        }
+      }
+      let actionFailed = false;
+      if (scenario.actions) {
+        for (const action of scenario.actions) {
+          console.error(`  Action: ${action.type} ${action.selector || ""}`);
+          try {
+            if (action.type === "click" && action.selector) {
+              await page.click(action.selector);
+            } else if (action.type === "type" && action.selector && action.value) {
+              await page.fill(action.selector, action.value);
+            } else if (action.type === "wait" && action.timeout) {
+              await page.waitForTimeout(action.timeout);
+            }
+          } catch (e) {
+            console.error(`  [WARN] Action failed: ${e}`);
+            actionFailed = true;
+            if (config.failOnActionError) {
+              break;
+            }
+          }
+        }
+        await page.waitForTimeout(500);
+      }
+      const currentPath = import_path4.default.join(dirs.current, `${label}.png`);
+      retries = 2;
+      while (retries >= 0) {
+        try {
+          await captureScreenshot(page, null, currentPath, {
+            fullPage: true,
+            maskSelectors: scenario.maskSelectors,
+            hideSelectors: scenario.hideSelectors
+          });
+          break;
+        } catch (e) {
+          if (retries === 0) throw e;
+          console.error(`  [WARN] Screenshot failed, retrying... (${retries} attempts left)`);
+          retries--;
+          await page.waitForTimeout(1e3);
+        }
+      }
+      console.error(`  Screenshot captured: ${currentPath}`);
+      const a11yResult = await runAxeAudit(page);
+      if (a11yResult.violations.length > 0) {
+        console.error(`  Accessibility violations: ${a11yResult.violations.length}`);
+      }
+      const baselinePath = import_path4.default.join(dirs.baseline, `${label}.png`);
+      const diffPath = import_path4.default.join(dirs.diff, `${label}.png`);
+      let status = "new";
+      let diffPixels = 0;
+      let diffPercentage = 0;
+      let finalDiffPath;
+      let finalBaselinePath;
+      let dimensionMismatch = false;
+      if (import_fs4.default.existsSync(baselinePath)) {
+        finalBaselinePath = baselinePath;
+        console.error("  Comparing with baseline...");
+        const result = compareImages(baselinePath, currentPath, diffPath, config.threshold);
+        diffPixels = result.diffPixels;
+        diffPercentage = result.diffPercentage;
+        dimensionMismatch = !result.isSameDimensions;
+        if (!result.isSameDimensions) {
+          status = "fail";
+          console.error(`  [FAIL] Dimension mismatch! Baseline and current images have different sizes.`);
+        } else if (result.diffPixels > 0) {
+          status = "fail";
+          finalDiffPath = diffPath;
+          console.error(`  [FAIL] Visual regression detected! Diff pixels: ${result.diffPixels} (${result.diffPercentage.toFixed(2)}%)`);
+          console.error(`  Diff image saved to: ${diffPath}`);
+        } else {
+          status = "pass";
+          console.error("  [PASS] No visual regression detected.");
+        }
+      } else {
+        console.error("  Baseline not found. Saving current as baseline.");
+        import_fs4.default.copyFileSync(currentPath, baselinePath);
+        console.error(`  Baseline saved to: ${baselinePath}`);
+        finalBaselinePath = baselinePath;
+      }
+      if (a11yResult.violations.length > 0) {
+        status = "fail";
+        console.error(`  [FAIL] Accessibility violations detected: ${a11yResult.violations.length}`);
+      }
+      if (actionFailed && config.failOnActionError) {
+        status = "fail";
+        console.error(`  [FAIL] Action execution failed.`);
+      }
+      results.push({
+        scenario: label,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        status,
+        diffPixels,
+        diffPercentage,
+        screenshotPath: currentPath,
+        diffPath: finalDiffPath,
+        baselinePath: finalBaselinePath,
+        a11yViolations: a11yResult.violations,
+        dimensionMismatch
+      });
+    }
+  }
+  await browser.close();
+  const reportData = {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    results
+  };
+  if (config.format === "json") {
+    console.log(JSON.stringify(results, null, 2));
+  } else if (config.format === "ai") {
+    const { formatAiReport: formatAiReport2 } = await Promise.resolve().then(() => (init_ai_reporter(), ai_reporter_exports));
+    console.log(formatAiReport2(results, outDir));
+  } else {
+    generateHtmlReport(reportData, outDir);
+  }
+  const hasFailures = results.some((r) => r.status === "fail");
+  return !hasFailures;
+}
+
+// src/cli.ts
+var cli = dist_default("difflens");
+cli.command("init", "Initialize DiffLens configuration").action(() => {
+  const configPath = import_path5.default.resolve(process.cwd(), "difflens.config.ts");
+  if (import_fs5.default.existsSync(configPath)) {
+    console.log("Configuration file already exists: difflens.config.ts");
+    return;
+  }
+  const template = `import { DiffLensConfig } from 'difflens';
+
+const config: DiffLensConfig = {
+  scenarios: [
+    {
+      label: 'example',
+      path: 'https://example.com',
+    },
+  ],
+  outDir: '.difflens',
+};
+
+export default config;
+`;
+  import_fs5.default.writeFileSync(configPath, template);
+  console.log("Created configuration file: difflens.config.ts");
+});
+cli.command("test", "Run visual regression tests").option("--format <type>", "Output format (default, json, ai)").option("--url <url>", "URL to test (overrides config file)").option("--label <label>", "Label for the test scenario", { default: "check" }).action(async (options) => {
+  console.error("Running tests...");
+  try {
+    let config;
+    if (options.url) {
+      config = {
+        scenarios: [{ label: options.label, path: options.url }],
+        outDir: ".difflens",
+        format: options.format
+      };
+    } else {
+      config = await loadConfig();
+      if (options.format) {
+        config.format = options.format;
+      }
+    }
+    const success = await runTests(config);
+    if (!success) {
+      console.error("Tests failed.");
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error("Test run failed:", error);
+    process.exit(1);
+  }
+});
+cli.command("report", "Generate HTML report").action(() => {
+  console.error("Generating report...");
+  console.error("Report generation is currently integrated into the test command.");
+});
+cli.help();
+cli.version(version);
+try {
+  cli.parse();
+} catch (error) {
+  console.error(error);
+  process.exit(1);
+}