html-validate 8.7.4 → 8.9.0

package/dist/es/cli.js

@@ -1,532 +1,560 @@
-import { l as legacyRequire, F as FileSystemConfigLoader, n as nodejsResolver } from './core-nodejs.js';
-import { g as getFormatter$1, U as UserError, e as ensureError, i as ignore, d as deepmerge, H as HtmlValidate, x as Reporter } from './core.js';
+import { l as legacyRequire, F as FileSystemConfigLoader, c as cjsResolver } from './core-nodejs.js';
+import { U as UserError, e as ensureError, g as getFormatter$1, i as ignore, d as deepmerge, S as Severity, H as HtmlValidate, y as Reporter } from './core.js';
 import path from 'node:path';
 import fs from 'fs';
 import { globSync } from 'glob';
 import prompts from 'prompts';
 import './meta-helper.js';
+import fs$1 from 'node:fs';
+import betterAjvErrors from '@sidvind/better-ajv-errors';
 import kleur from 'kleur';
 
 const DEFAULT_EXTENSIONS = ["html"];
 function isDirectory(filename) {
-    const st = fs.statSync(filename);
-    return st.isDirectory();
+  const st = fs.statSync(filename);
+  return st.isDirectory();
 }
 function join(stem, filename) {
-    if (path.isAbsolute(filename)) {
-        return path.normalize(filename);
-    }
-    else {
-        return path.normalize(path.join(stem, filename));
-    }
+  if (path.isAbsolute(filename)) {
+    return path.normalize(filename);
+  } else {
+    return path.normalize(path.join(stem, filename));
+  }
 }
 function directoryPattern(extensions) {
-    switch (extensions.length) {
-        case 0:
-            return "**/*";
-        case 1:
-            return `**/*.${extensions[0]}`;
-        default:
-            return `**/*.{${extensions.join(",")}}`;
-    }
+  switch (extensions.length) {
+    case 0:
+      return "**/*";
+    case 1:
+      return `**/*.${extensions[0]}`;
+    default:
+      return `**/*.{${extensions.join(",")}}`;
+  }
 }
-/**
- * Takes a number of file patterns (globs) and returns array of expanded
- * filenames.
- */
 function expandFiles(patterns, options) {
-    var _a, _b;
-    const cwd = (_a = options.cwd) !== null && _a !== void 0 ? _a : process.cwd();
-    const extensions = (_b = options.extensions) !== null && _b !== void 0 ? _b : DEFAULT_EXTENSIONS;
-    const files = patterns.reduce((result, pattern) => {
-        /* process - as standard input */
-        if (pattern === "-") {
-            result.push("/dev/stdin");
-            return result;
-        }
-        for (const filename of globSync(pattern, { cwd })) {
-            /* if file is a directory recursively expand files from it */
-            const fullpath = join(cwd, filename);
-            if (isDirectory(fullpath)) {
-                const dir = expandFiles([directoryPattern(extensions)], { ...options, cwd: fullpath });
-                result = result.concat(dir.map((cur) => join(filename, cur)));
-                continue;
-            }
-            result.push(fullpath);
-        }
-        return result.sort((a, b) => {
-            const pa = a.split("/").length;
-            const pb = b.split("/").length;
-            if (pa !== pb) {
-                return pa - pb;
-            }
-            else {
-                return a > b ? 1 : -1;
-            }
-        });
-    }, []);
-    /* only return unique matches */
-    return Array.from(new Set(files));
+  const cwd = options.cwd ?? process.cwd();
+  const extensions = options.extensions ?? DEFAULT_EXTENSIONS;
+  const files = patterns.reduce((result, pattern) => {
+    if (pattern === "-") {
+      result.push("/dev/stdin");
+      return result;
+    }
+    for (const filename of globSync(pattern, { cwd })) {
+      const fullpath = join(cwd, filename);
+      if (isDirectory(fullpath)) {
+        const dir = expandFiles([directoryPattern(extensions)], { ...options, cwd: fullpath });
+        result = result.concat(dir.map((cur) => join(filename, cur)));
+        continue;
+      }
+      result.push(fullpath);
+    }
+    return result.sort((a, b) => {
+      const pa = a.split("/").length;
+      const pb = b.split("/").length;
+      if (pa !== pb) {
+        return pa - pb;
+      } else {
+        return a > b ? 1 : -1;
+      }
+    });
+  }, []);
+  return Array.from(new Set(files));
 }
 
 function wrap(formatter, dst) {
-    return (results) => {
-        const output = formatter(results);
-        if (dst) {
-            const dir = path.dirname(dst);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
-            }
-            fs.writeFileSync(dst, output, "utf-8");
-            return "";
-        }
-        else {
-            return output;
-        }
-    };
+  return (results) => {
+    const output = formatter(results);
+    if (dst) {
+      const dir = path.dirname(dst);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+      fs.writeFileSync(dst, output, "utf-8");
+      return "";
+    } else {
+      return output;
+    }
+  };
 }
 function loadFormatter(name) {
-    const fn = getFormatter$1(name);
-    if (fn) {
-        return fn;
-    }
-    try {
-        return legacyRequire(name);
-    }
-    catch (error) {
-        throw new UserError(`No formatter named "${name}"`, ensureError(error));
-    }
+  const fn = getFormatter$1(name);
+  if (fn) {
+    return fn;
+  }
+  try {
+    return legacyRequire(name);
+  } catch (error) {
+    throw new UserError(`No formatter named "${name}"`, ensureError(error));
+  }
 }
 function getFormatter(formatters) {
-    const fn = formatters.split(",").map((cur) => {
-        const [name, dst] = cur.split("=", 2);
-        const fn = loadFormatter(name);
-        return wrap(fn, dst);
-    });
-    return (report) => {
-        return fn
-            .map((formatter) => formatter(report.results))
-            .filter(Boolean)
-            .join("\n");
-    };
+  const fn = formatters.split(",").map((cur) => {
+    const [name, dst] = cur.split("=", 2);
+    const fn2 = loadFormatter(name);
+    return wrap(fn2, dst);
+  });
+  return (report) => {
+    return fn.map((formatter) => formatter(report.results)).filter(Boolean).join("\n");
+  };
 }
 
 class IsIgnored {
-    constructor() {
-        this.cacheIgnore = new Map();
-    }
-    /**
-     * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
-     * one of them contains a pattern matching given filename.
-     */
-    isIgnored(filename) {
-        return this.match(filename);
-    }
-    /**
-     * Clear cache
-     */
-    clearCache() {
-        this.cacheIgnore.clear();
-    }
-    match(target) {
-        let current = path.dirname(target);
-        // eslint-disable-next-line no-constant-condition -- breaks out when filesystem is traversed
-        while (true) {
-            const relative = path.relative(current, target);
-            const filename = path.join(current, ".htmlvalidateignore");
-            /* test filename (relative to the ignore file) against the patterns */
-            const ig = this.parseFile(filename);
-            if (ig && ig.ignores(relative)) {
-                return true;
-            }
-            /* get the parent directory */
-            const child = current;
-            current = path.dirname(current);
-            /* stop if this is the root directory */
-            if (current === child) {
-                break;
-            }
-        }
-        return false;
-    }
-    parseFile(filename) {
-        if (this.cacheIgnore.has(filename)) {
-            return this.cacheIgnore.get(filename);
-        }
-        if (!fs.existsSync(filename)) {
-            this.cacheIgnore.set(filename, undefined);
-            return undefined;
-        }
-        const content = fs.readFileSync(filename, "utf-8");
-        const ig = ignore().add(content);
-        this.cacheIgnore.set(filename, ig);
-        return ig;
-    }
+  constructor() {
+    this.cacheIgnore = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
+   * one of them contains a pattern matching given filename.
+   */
+  isIgnored(filename) {
+    return this.match(filename);
+  }
+  /**
+   * Clear cache
+   */
+  clearCache() {
+    this.cacheIgnore.clear();
+  }
+  match(target) {
+    let current = path.dirname(target);
+    while (true) {
+      const relative = path.relative(current, target);
+      const filename = path.join(current, ".htmlvalidateignore");
+      const ig = this.parseFile(filename);
+      if (ig && ig.ignores(relative)) {
+        return true;
+      }
+      const child = current;
+      current = path.dirname(current);
+      if (current === child) {
+        break;
+      }
+    }
+    return false;
+  }
+  parseFile(filename) {
+    if (this.cacheIgnore.has(filename)) {
+      return this.cacheIgnore.get(filename);
+    }
+    if (!fs.existsSync(filename)) {
+      this.cacheIgnore.set(filename, void 0);
+      return void 0;
+    }
+    const content = fs.readFileSync(filename, "utf-8");
+    const ig = ignore().add(content);
+    this.cacheIgnore.set(filename, ig);
+    return ig;
+  }
 }
 
-var Frameworks;
-(function (Frameworks) {
-    Frameworks["angularjs"] = "AngularJS";
-    Frameworks["vuejs"] = "Vue.js";
-    Frameworks["markdown"] = "Markdown";
-})(Frameworks || (Frameworks = {}));
 const frameworkConfig = {
-    [Frameworks.angularjs]: {
-        transform: {
-            "^.*\\.js$": "html-validate-angular/js",
-            "^.*\\.html$": "html-validate-angular/html",
-        },
-    },
-    [Frameworks.vuejs]: {
-        plugins: ["html-validate-vue"],
-        extends: ["html-validate-vue:recommended"],
-        transform: {
-            "^.*\\.vue$": "html-validate-vue",
-        },
-    },
-    [Frameworks.markdown]: {
-        transform: {
-            "^.*\\.md$": "html-validate-markdown",
-        },
-    },
+  ["AngularJS" /* angularjs */]: {
+    transform: {
+      "^.*\\.js$": "html-validate-angular/js",
+      "^.*\\.html$": "html-validate-angular/html"
+    }
+  },
+  ["Vue.js" /* vuejs */]: {
+    plugins: ["html-validate-vue"],
+    extends: ["html-validate-vue:recommended"],
+    transform: {
+      "^.*\\.vue$": "html-validate-vue"
+    }
+  },
+  ["Markdown" /* markdown */]: {
+    transform: {
+      "^.*\\.md$": "html-validate-markdown"
+    }
+  }
 };
 function addFrameworks(src, frameworks) {
-    let config = src;
-    for (const framework of frameworks) {
-        config = deepmerge(config, frameworkConfig[framework]);
-    }
-    return config;
+  let config = src;
+  for (const framework of frameworks) {
+    config = deepmerge(config, frameworkConfig[framework]);
+  }
+  return config;
 }
 function writeConfig(dst, config) {
-    return new Promise((resolve, reject) => {
-        fs.writeFile(dst, JSON.stringify(config, null, 2), (err) => {
-            if (err)
-                reject(err);
-            resolve();
-        });
+  return new Promise((resolve, reject) => {
+    fs.writeFile(dst, JSON.stringify(config, null, 2), (err) => {
+      if (err)
+        reject(err);
+      resolve();
     });
+  });
 }
 async function init$1(cwd) {
-    const filename = `${cwd}/.htmlvalidate.json`;
-    const exists = fs.existsSync(filename);
-    const initialConfig = {
-        elements: ["html5"],
-        extends: ["html-validate:recommended"],
-    };
-    /* confirm overwrite */
-    if (exists) {
-        const result = await prompts({
-            name: "overwrite",
-            type: "confirm",
-            message: "A .htmlvalidate.json file already exists, do you want to overwrite it?",
-        });
-        if (!result.overwrite) {
-            return Promise.reject();
-        }
-    }
-    const questions = [
-        {
-            name: "frameworks",
-            type: "multiselect",
-            choices: [
-                { title: Frameworks.angularjs, value: Frameworks.angularjs },
-                { title: Frameworks.vuejs, value: Frameworks.vuejs },
-                { title: Frameworks.markdown, value: Frameworks.markdown },
-            ],
-            message: "Support additional frameworks?",
-        },
-    ];
-    /* prompt user for questions */
-    const answers = await prompts(questions);
-    /* write configuration to file */
-    let config = initialConfig;
-    config = addFrameworks(config, answers.frameworks);
-    await writeConfig(filename, config);
-    return {
-        filename,
-    };
+  const filename = `${cwd}/.htmlvalidate.json`;
+  const exists = fs.existsSync(filename);
+  const initialConfig = {
+    elements: ["html5"],
+    extends: ["html-validate:recommended"]
+  };
+  if (exists) {
+    const result = await prompts({
+      name: "overwrite",
+      type: "confirm",
+      message: "A .htmlvalidate.json file already exists, do you want to overwrite it?"
+    });
+    if (!result.overwrite) {
+      return Promise.reject();
+    }
+  }
+  const questions = [
+    {
+      name: "frameworks",
+      type: "multiselect",
+      choices: [
+        { title: "AngularJS" /* angularjs */, value: "AngularJS" /* angularjs */ },
+        { title: "Vue.js" /* vuejs */, value: "Vue.js" /* vuejs */ },
+        { title: "Markdown" /* markdown */, value: "Markdown" /* markdown */ }
+      ],
+      message: "Support additional frameworks?"
+    }
+  ];
+  const answers = await prompts(questions);
+  let config = initialConfig;
+  config = addFrameworks(config, answers.frameworks);
+  await writeConfig(filename, config);
+  return {
+    filename
+  };
+}
+
+function parseSeverity(ruleId, severity) {
+  switch (severity) {
+    case "off":
+    case "0":
+      return Severity.DISABLED;
+    case "warn":
+    case "1":
+      return Severity.WARN;
+    case "error":
+    case "2":
+      return Severity.ERROR;
+    default:
+      throw new Error(`Invalid severity "${severity}" for rule "${ruleId}"`);
+  }
+}
+
+function parseItem(value) {
+  if (value.includes(":")) {
+    const [ruleId, severity] = value.split(":", 2);
+    return { ruleId, severity: parseSeverity(ruleId, severity) };
+  } else {
+    return { ruleId: value, severity: Severity.ERROR };
+  }
+}
+function getRuleConfig(values) {
+  if (typeof values === "string") {
+    return getRuleConfig([values]);
+  }
+  return values.reduce((parsedRules, value) => {
+    const { ruleId, severity } = parseItem(value.trim());
+    return { [ruleId]: severity, ...parsedRules };
+  }, {});
 }
 
 const defaultConfig = {
-    extends: ["html-validate:recommended"],
+  extends: ["html-validate:recommended"]
 };
 function getBaseConfig(filename) {
-    if (filename) {
-        const resolver = nodejsResolver();
-        const configData = resolver.resolveConfig(path.resolve(filename), { cache: false });
-        if (!configData) {
-            throw new UserError(`Failed to read configuration from "${filename}"`);
-        }
-        return configData;
-    }
-    else {
-        return defaultConfig;
-    }
+  if (filename) {
+    const resolver = cjsResolver();
+    const configData = resolver.resolveConfig(path.resolve(filename), { cache: false });
+    if (!configData) {
+      throw new UserError(`Failed to read configuration from "${filename}"`);
+    }
+    return configData;
+  } else {
+    return defaultConfig;
+  }
 }
-/**
- * @public
- */
 class CLI {
-    /**
-     * Create new CLI helper.
-     *
-     * Can be used to create tooling with similar properties to bundled CLI
-     * script.
-     */
-    constructor(options) {
-        this.options = options !== null && options !== void 0 ? options : {};
-        this.config = this.resolveConfig();
-        this.loader = new FileSystemConfigLoader(this.config);
-        this.ignored = new IsIgnored();
-    }
-    /**
-     * Returns list of files matching patterns and are not ignored. Filenames will
-     * have absolute paths.
-     *
-     * @public
-     */
-    expandFiles(patterns, options = {}) {
-        return expandFiles(patterns, options).filter((filename) => !this.isIgnored(filename));
-    }
-    getFormatter(formatters) {
-        return getFormatter(formatters);
-    }
-    /**
-     * Initialize project with a new configuration.
-     *
-     * A new `.htmlvalidate.json` file will be placed in the path provided by
-     * `cwd`.
-     */
-    init(cwd) {
-        return init$1(cwd);
-    }
-    /**
-     * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
-     * one of them contains a pattern matching given filename.
-     */
-    isIgnored(filename) {
-        return this.ignored.isIgnored(filename);
-    }
-    /**
-     * Clear cache.
-     *
-     * Previously fetched [[HtmlValidate]] instances must either be fetched again
-     * or call [[HtmlValidate.flushConfigCache]].
-     */
-    /* istanbul ignore next: each method is tested separately */
-    clearCache() {
-        this.loader.flushCache();
-        this.ignored.clearCache();
-    }
-    /**
-     * Get HtmlValidate instance with configuration based on options passed to the
-     * constructor.
-     *
-     * @internal
-     */
-    getLoader() {
-        return this.loader;
-    }
-    /**
-     * Get HtmlValidate instance with configuration based on options passed to the
-     * constructor.
-     *
-     * @public
-     */
-    getValidator() {
-        const loader = this.getLoader();
-        return new HtmlValidate(loader);
-    }
-    /**
-     * @internal
-     */
-    getConfig() {
-        return this.config;
-    }
-    resolveConfig() {
-        const { options } = this;
-        const config = getBaseConfig(options.configFile);
-        if (options.rules) {
-            const rules = Array.isArray(options.rules) ? options.rules : [options.rules];
-            try {
-                const severityMap = { off: 0, warn: 1, error: 2 };
-                const ruleConfig = rules.reduce((parsedRules, rule) => {
-                    var _a;
-                    const [ruleName, ruleSeverity] = rule.trim().split(":");
-                    const severityValue = (_a = severityMap[ruleSeverity]) !== null && _a !== void 0 ? _a : parseInt(ruleSeverity, 10);
-                    if (!Object.values(severityMap).includes(severityValue)) {
-                        throw new Error(`Invalid severity value for rule "${ruleName}": ${ruleSeverity}`);
-                    }
-                    parsedRules[ruleName] = severityValue;
-                    return parsedRules;
-                }, {});
-                config.extends = [];
-                config.rules = ruleConfig;
-            }
-            catch (err) /* istanbul ignore next */ {
-                const message = err instanceof Error ? err.message : String(err);
-                throw new UserError(`Error while parsing --rule option "{${rules.join(",")}": ${message}.\n`);
-            }
-        }
-        return config;
+  /**
+   * Create new CLI helper.
+   *
+   * Can be used to create tooling with similar properties to bundled CLI
+   * script.
+   */
+  constructor(options) {
+    this.options = options ?? {};
+    this.config = null;
+    this.loader = null;
+    this.ignored = new IsIgnored();
+  }
+  /**
+   * Returns list of files matching patterns and are not ignored. Filenames will
+   * have absolute paths.
+   *
+   * @public
+   */
+  expandFiles(patterns, options = {}) {
+    return expandFiles(patterns, options).filter((filename) => !this.isIgnored(filename));
+  }
+  getFormatter(formatters) {
+    return getFormatter(formatters);
+  }
+  /**
+   * Initialize project with a new configuration.
+   *
+   * A new `.htmlvalidate.json` file will be placed in the path provided by
+   * `cwd`.
+   */
+  init(cwd) {
+    return init$1(cwd);
+  }
+  /**
+   * Searches ".htmlvalidateignore" files from filesystem and returns `true` if
+   * one of them contains a pattern matching given filename.
+   */
+  isIgnored(filename) {
+    return this.ignored.isIgnored(filename);
+  }
+  /**
+   * Clear cache.
+   *
+   * Previously fetched [[HtmlValidate]] instances must either be fetched again
+   * or call [[HtmlValidate.flushConfigCache]].
+   */
+  /* istanbul ignore next: each method is tested separately */
+  clearCache() {
+    if (this.loader) {
+      this.loader.flushCache();
+    }
+    this.ignored.clearCache();
+  }
+  /**
+   * Get HtmlValidate instance with configuration based on options passed to the
+   * constructor.
+   *
+   * @internal
+   */
+  getLoader() {
+    if (!this.loader) {
+      this.loader = new FileSystemConfigLoader(this.getConfig());
+    }
+    return this.loader;
+  }
+  /**
+   * Get HtmlValidate instance with configuration based on options passed to the
+   * constructor.
+   *
+   * @public
+   */
+  getValidator() {
+    const loader = this.getLoader();
+    return new HtmlValidate(loader);
+  }
+  /**
+   * @internal
+   */
+  getConfig() {
+    if (!this.config) {
+      this.config = this.resolveConfig();
+    }
+    return this.config;
+  }
+  resolveConfig() {
+    const { options } = this;
+    const config = getBaseConfig(options.configFile);
+    if (options.rules) {
+      config.extends = [];
+      config.rules = getRuleConfig(options.rules);
     }
+    return config;
+  }
+}
+
+function prettyError(err) {
+  let json;
+  if (err.filename && fs$1.existsSync(err.filename)) {
+    json = fs$1.readFileSync(err.filename, "utf-8");
+  }
+  return betterAjvErrors(err.schema, err.obj, err.errors, {
+    format: "cli",
+    indent: 2,
+    json
+  });
+}
+function handleSchemaValidationError(console, err) {
+  if (err.filename) {
+    const filename = path.relative(process.cwd(), err.filename);
+    console.error(kleur.red(`A configuration error was found in "${filename}":`));
+  } else {
+    console.error(kleur.red(`A configuration error was found:`));
+  }
+  console.group();
+  {
+    console.error(prettyError(err));
+  }
+  console.groupEnd();
 }
 
-/**
- * @internal
- */
-var Mode;
-(function (Mode) {
-    Mode[Mode["LINT"] = 0] = "LINT";
-    Mode[Mode["INIT"] = 1] = "INIT";
-    Mode[Mode["DUMP_EVENTS"] = 2] = "DUMP_EVENTS";
-    Mode[Mode["DUMP_TOKENS"] = 3] = "DUMP_TOKENS";
-    Mode[Mode["DUMP_TREE"] = 4] = "DUMP_TREE";
-    Mode[Mode["DUMP_SOURCE"] = 5] = "DUMP_SOURCE";
-    Mode[Mode["PRINT_CONFIG"] = 6] = "PRINT_CONFIG";
-})(Mode || (Mode = {}));
+var Mode = /* @__PURE__ */ ((Mode2) => {
+  Mode2[Mode2["LINT"] = 0] = "LINT";
+  Mode2[Mode2["INIT"] = 1] = "INIT";
+  Mode2[Mode2["DUMP_EVENTS"] = 2] = "DUMP_EVENTS";
+  Mode2[Mode2["DUMP_TOKENS"] = 3] = "DUMP_TOKENS";
+  Mode2[Mode2["DUMP_TREE"] = 4] = "DUMP_TREE";
+  Mode2[Mode2["DUMP_SOURCE"] = 5] = "DUMP_SOURCE";
+  Mode2[Mode2["PRINT_CONFIG"] = 6] = "PRINT_CONFIG";
+  return Mode2;
+})(Mode || {});
 function modeToFlag(mode) {
-    switch (mode) {
-        case Mode.LINT:
-            return null;
-        case Mode.INIT:
-            return "--init";
-        case Mode.DUMP_EVENTS:
-            return "--dump-events";
-        case Mode.DUMP_TOKENS:
-            return "--dump-tokens";
-        case Mode.DUMP_TREE:
-            return "--dump-tree";
-        case Mode.DUMP_SOURCE:
-            return "--dump-source";
-        case Mode.PRINT_CONFIG:
-            return "--print-config";
-    }
+  switch (mode) {
+    case 0 /* LINT */:
+      return null;
+    case 1 /* INIT */:
+      return "--init";
+    case 2 /* DUMP_EVENTS */:
+      return "--dump-events";
+    case 3 /* DUMP_TOKENS */:
+      return "--dump-tokens";
+    case 4 /* DUMP_TREE */:
+      return "--dump-tree";
+    case 5 /* DUMP_SOURCE */:
+      return "--dump-source";
+    case 6 /* PRINT_CONFIG */:
+      return "--print-config";
+  }
 }
 
 function renameStdin(report, filename) {
-    const stdin = report.results.find((cur) => cur.filePath === "/dev/stdin");
-    if (stdin) {
-        stdin.filePath = filename;
-    }
+  const stdin = report.results.find((cur) => cur.filePath === "/dev/stdin");
+  if (stdin) {
+    stdin.filePath = filename;
+  }
 }
-function lint(htmlvalidate, output, files, options) {
-    const reports = files.map((filename) => {
-        try {
-            return htmlvalidate.validateFileSync(filename);
-        }
-        catch (err) {
-            const message = kleur.red(`Validator crashed when parsing "${filename}"`);
-            output.write(`${message}\n`);
-            throw err;
-        }
-    });
-    const merged = Reporter.merge(reports);
-    /* rename stdin if an explicit filename was passed */
-    if (options.stdinFilename) {
-        renameStdin(merged, options.stdinFilename);
-    }
-    output.write(options.formatter(merged));
-    if (options.maxWarnings >= 0 && merged.warningCount > options.maxWarnings) {
-        output.write(`\nhtml-validate found too many warnings (maximum: ${options.maxWarnings}).\n`);
-        return Promise.resolve(false);
-    }
-    return Promise.resolve(merged.valid);
+async function lint(htmlvalidate, output, files, options) {
+  const reports = files.map(async (filename) => {
+    try {
+      return await htmlvalidate.validateFile(filename);
+    } catch (err) {
+      const message = kleur.red(`Validator crashed when parsing "${filename}"`);
+      output.write(`${message}
+`);
+      throw err;
+    }
+  });
+  const merged = await Reporter.merge(reports);
+  if (options.stdinFilename) {
+    renameStdin(merged, options.stdinFilename);
+  }
+  output.write(options.formatter(merged));
+  if (options.maxWarnings >= 0 && merged.warningCount > options.maxWarnings) {
+    output.write(`
+html-validate found too many warnings (maximum: ${options.maxWarnings}).
+`);
+    return false;
+  }
+  return merged.valid;
 }
 
 async function init(cli, output, options) {
-    const result = await cli.init(options.cwd);
-    output.write(`Configuration written to "${result.filename}"\n`);
-    return true;
+  const result = await cli.init(options.cwd);
+  output.write(`Configuration written to "${result.filename}"
+`);
+  return true;
 }
 
 async function printConfig(htmlvalidate, output, files) {
-    if (files.length > 1) {
-        output.write(`\`--print-config\` expected a single filename but got multiple:\n\n`);
-        for (const filename of files) {
-            output.write(`  - ${filename}\n`);
-        }
-        output.write("\n");
-        return false;
+  if (files.length > 1) {
+    output.write(`\`--print-config\` expected a single filename but got multiple:
+
+`);
+    for (const filename of files) {
+      output.write(`  - ${filename}
+`);
     }
-    const config = await htmlvalidate.getConfigFor(files[0]);
-    const json = JSON.stringify(config.getConfigData(), null, 2);
-    output.write(`${json}\n`);
-    return true;
+    output.write("\n");
+    return false;
+  }
+  const config = await htmlvalidate.getConfigFor(files[0]);
+  const json = JSON.stringify(config.getConfigData(), null, 2);
+  output.write(`${json}
+`);
+  return true;
 }
 
 const jsonIgnored = [
-    "annotation",
-    "blockedRules",
-    "cache",
-    "closed",
-    "depth",
-    "disabledRules",
-    "nodeType",
-    "unique",
-    "voidElement",
+  "annotation",
+  "blockedRules",
+  "cache",
+  "closed",
+  "depth",
+  "disabledRules",
+  "nodeType",
+  "unique",
+  "voidElement"
 ];
 const jsonFiltered = [
-    "childNodes",
-    "children",
-    "data",
-    "meta",
-    "metaElement",
-    "originalData",
-    "parent",
+  "childNodes",
+  "children",
+  "data",
+  "meta",
+  "metaElement",
+  "originalData",
+  "parent"
 ];
 function isLocation(key, value) {
-    return Boolean(value && (key === "location" || key.endsWith("Location")));
+  return Boolean(value && (key === "location" || key.endsWith("Location")));
 }
 function isIgnored(key) {
-    return Boolean(key.startsWith("_") || jsonIgnored.includes(key));
+  return Boolean(key.startsWith("_") || jsonIgnored.includes(key));
 }
 function isFiltered(key, value) {
-    return Boolean(value && jsonFiltered.includes(key));
+  return Boolean(value && jsonFiltered.includes(key));
 }
 function eventReplacer(key, value) {
-    if (isLocation(key, value)) {
-        return `${value.filename}:${value.line}:${value.column}`;
-    }
-    if (isIgnored(key)) {
-        return undefined;
-    }
-    if (isFiltered(key, value)) {
-        return "[truncated]";
-    }
-    return value;
+  if (isLocation(key, value)) {
+    return `${value.filename}:${value.line}:${value.column}`;
+  }
+  if (isIgnored(key)) {
+    return void 0;
+  }
+  if (isFiltered(key, value)) {
+    return "[truncated]";
+  }
+  return value;
 }
 function eventFormatter(entry) {
-    const strdata = JSON.stringify(entry.data, eventReplacer, 2);
-    return `${entry.event}: ${strdata}`;
+  const strdata = JSON.stringify(entry.data, eventReplacer, 2);
+  return `${entry.event}: ${strdata}`;
 }
 
 function dump(htmlvalidate, output, files, mode) {
-    let lines = [];
-    switch (mode) {
-        case Mode.DUMP_EVENTS:
-            lines = files.map((filename) => htmlvalidate.dumpEvents(filename).map(eventFormatter));
-            break;
-        case Mode.DUMP_TOKENS:
-            lines = files.map((filename) => htmlvalidate.dumpTokens(filename).map((entry) => {
-                const data = JSON.stringify(entry.data);
-                return `TOKEN: ${entry.token}\n  Data: ${data}\n  Location: ${entry.location}`;
-            }));
-            break;
-        case Mode.DUMP_TREE:
-            lines = files.map((filename) => htmlvalidate.dumpTree(filename));
-            break;
-        case Mode.DUMP_SOURCE:
-            lines = files.map((filename) => htmlvalidate.dumpSource(filename));
-            break;
-        default:
-            throw new Error(`Unknown mode "${mode}"`);
-    }
-    const flat = lines.reduce((s, c) => s.concat(c), []);
-    output.write(flat.join("\n"));
-    output.write("\n");
-    return Promise.resolve(true);
+  let lines = [];
+  switch (mode) {
+    case Mode.DUMP_EVENTS:
+      lines = files.map(
+        (filename) => htmlvalidate.dumpEvents(filename).map(eventFormatter)
+      );
+      break;
+    case Mode.DUMP_TOKENS:
+      lines = files.map(
+        (filename) => htmlvalidate.dumpTokens(filename).map((entry) => {
+          const data = JSON.stringify(entry.data);
+          return `TOKEN: ${entry.token}
+  Data: ${data}
+  Location: ${entry.location}`;
+        })
+      );
+      break;
+    case Mode.DUMP_TREE:
+      lines = files.map((filename) => htmlvalidate.dumpTree(filename));
+      break;
+    case Mode.DUMP_SOURCE:
+      lines = files.map((filename) => htmlvalidate.dumpSource(filename));
+      break;
+    default:
+      throw new Error(`Unknown mode "${mode}"`);
+  }
+  const flat = lines.reduce((s, c) => s.concat(c), []);
+  output.write(flat.join("\n"));
+  output.write("\n");
+  return Promise.resolve(true);
 }
 
-export { CLI as C, Mode as M, dump as d, init as i, lint as l, modeToFlag as m, printConfig as p };
+export { CLI as C, Mode as M, dump as d, handleSchemaValidationError as h, init as i, lint as l, modeToFlag as m, printConfig as p };
 //# sourceMappingURL=cli.js.map