@t09tanaka/test-gates 0.0.0-stage → 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1233 @@
+"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 __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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_FORBIDDEN_SOURCE: () => DEFAULT_FORBIDDEN_SOURCE,
+  DEFAULT_GATE_EXTENSIONS: () => DEFAULT_GATE_EXTENSIONS,
+  DEFAULT_IMPURE_IMPORTS: () => DEFAULT_IMPURE_IMPORTS,
+  DEFAULT_IMPURE_NAMED_IMPORTS: () => DEFAULT_IMPURE_NAMED_IMPORTS,
+  DEFAULT_IMPURE_PATHS: () => DEFAULT_IMPURE_PATHS,
+  DEFAULT_REPORT_FILE: () => DEFAULT_REPORT_FILE,
+  EXCLUDE_ENV: () => EXCLUDE_ENV,
+  MANIFEST_FILE: () => MANIFEST_FILE,
+  ManifestError: () => ManifestError,
+  checkGates: () => checkGates,
+  formatSummary: () => formatSummary,
+  formatSurvivor: () => formatSurvivor,
+  gateSpecs: () => gateSpecs,
+  judgeLcov: () => judgeLcov,
+  judgeMutationReport: () => judgeMutationReport,
+  judgeSelfcheck: () => judgeSelfcheck,
+  loadGates: () => loadGates,
+  normalizeCode: () => normalizeCode,
+  parseLcov: () => parseLcov,
+  parseManifest: () => parseManifest,
+  readManifest: () => readManifest,
+  resolveSettings: () => resolveSettings,
+  sliceByLocation: () => sliceByLocation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/load.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/core/manifest.ts
+var MANIFEST_FILE = "test-gates.json";
+var ManifestError = class extends Error {
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFilled(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function allowanceProblems(entry) {
+  if (!isRecord(entry)) {
+    return [" must be an object"];
+  }
+  const problems = [];
+  if (!isFilled(entry.mutator)) {
+    problems.push(': "mutator" is missing');
+  }
+  if (!isFilled(entry.original)) {
+    problems.push(': "original" is missing');
+  }
+  if (typeof entry.replacement !== "string") {
+    problems.push(': "replacement" is missing');
+  }
+  if (!isFilled(entry.reason)) {
+    problems.push(': "reason" is missing (say why the mutant cannot be observed)');
+  }
+  if (entry.occurrence !== void 0 && !(Number.isInteger(entry.occurrence) && entry.occurrence >= 1)) {
+    problems.push(': "occurrence" must be an integer >= 1');
+  }
+  return problems;
+}
+function validateEquivalentMutants(gatePath, value) {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    return [{ file: MANIFEST_FILE, message: `${gatePath}: equivalentMutants must be an array` }];
+  }
+  return value.flatMap(
+    (entry, index) => allowanceProblems(entry).map((problem) => ({
+      file: MANIFEST_FILE,
+      message: `${gatePath}: equivalentMutants[${index}]${problem}`
+    }))
+  );
+}
+function isUsableEquivalentMutant(entry) {
+  return allowanceProblems(entry).length === 0;
+}
+function parseEntries(kind, entries, fields, violations) {
+  const usable = [];
+  const seen = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const at = `${kind}[${index}]`;
+    if (!isRecord(entry)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at} must be an object` });
+      return;
+    }
+    if (!isFilled(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at}: "path" is missing` });
+      return;
+    }
+    for (const field of fields) {
+      if (!isFilled(entry[field])) {
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${entry.path}: "${field}" is missing in ${kind}`
+        });
+      }
+    }
+    if (seen.has(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${entry.path}: listed twice in ${kind}` });
+      return;
+    }
+    seen.add(entry.path);
+    usable.push(entry);
+  });
+  return usable;
+}
+function parseManifest(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new ManifestError(`${MANIFEST_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!isRecord(raw)) {
+    throw new ManifestError(`${MANIFEST_FILE} must be a JSON object`);
+  }
+  if (!Array.isArray(raw.gates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "gates" must be an array`);
+  }
+  if (raw.candidates !== void 0 && !Array.isArray(raw.candidates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "candidates" must be an array`);
+  }
+  for (const key of Object.keys(raw)) {
+    if (!["$schema", "gates", "candidates", "settings"].includes(key)) {
+      throw new ManifestError(`${MANIFEST_FILE}: unknown top-level key ${JSON.stringify(key)}`);
+    }
+  }
+  const violations = [];
+  if (raw.gates.length === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "gates is empty. A project with nothing to gate should not have this file"
+    });
+  }
+  const gates = parseEntries("gates", raw.gates, ["decides", "impact"], violations);
+  const candidates = parseEntries(
+    "candidates",
+    raw.candidates ?? [],
+    ["decides", "blocker"],
+    violations
+  );
+  const gatePaths = new Set(gates.map((gate) => gate.path));
+  for (const candidate of candidates) {
+    if (gatePaths.has(candidate.path)) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${candidate.path}: listed in both gates and candidates`
+      });
+    }
+  }
+  for (const gate of gates) {
+    violations.push(...validateEquivalentMutants(gate.path, gate.equivalentMutants));
+  }
+  return { gates, candidates, settings: raw.settings, violations };
+}
+
+// src/core/settings.ts
+var DEFAULT_REPORT_FILE = "reports/mutation/mutation.json";
+var DEFAULT_GATE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var DEFAULT_IMPURE_IMPORTS = [
+  { pattern: "^@nestjs/", reason: "NestJS runtime (DI, decorators)" },
+  { pattern: "^class-(validator|transformer)$", reason: "decorator-based DTO library" },
+  {
+    pattern: "^(typeorm|sequelize|mongoose|knex|pg|mysql|mysql2|ioredis|redis)(/|$)",
+    reason: "database client"
+  },
+  { pattern: "^@prisma/adapter-", reason: "database client" },
+  { pattern: "^(react|react-dom)(/|$)", reason: "React runtime" },
+  { pattern: "^next(/|$)", reason: "Next.js runtime" },
+  { pattern: "^(server-only|client-only)$", reason: "Next.js execution environment" },
+  { pattern: "^(vue|vue-router|vue-i18n|pinia)(/|$)", reason: "Vue runtime" },
+  { pattern: "^nuxt(/|$)", reason: "Nuxt runtime" },
+  { pattern: "^#(app|imports)(/|$)", reason: "Nuxt runtime" },
+  { pattern: "\\.vue$", reason: "component" },
+  {
+    pattern: "^(express|express-jwt|fastify|koa|rxjs|passport)(/|$)",
+    reason: "HTTP framework runtime"
+  },
+  { pattern: "^passport-", reason: "HTTP framework runtime" },
+  {
+    pattern: "^(axios|openapi-fetch|stripe|nodemailer|firebase-admin)(/|$)",
+    reason: "HTTP client / external service SDK"
+  },
+  { pattern: "^@(aws-sdk|sentry|slack|stripe)/", reason: "external service SDK" },
+  {
+    pattern: "^(node:)?(fs|http|https|http2|net|tls|dgram|dns|child_process|worker_threads)(/|$)",
+    reason: "file system / network / process access"
+  }
+];
+var DEFAULT_IMPURE_NAMED_IMPORTS = [
+  { module: "@prisma/client", names: ["PrismaClient"], reason: "connects to the database" }
+];
+var DEFAULT_IMPURE_PATHS = [
+  { pattern: "\\.(vue|jsx|tsx)$", reason: "component file" },
+  { pattern: "\\.d\\.[cm]?ts$", reason: "type declaration file" }
+];
+var DEFAULT_FORBIDDEN_SOURCE = [
+  {
+    pattern: `^\\s*(['"])use (client|server)\\1`,
+    reason: "'use client' / 'use server' directive (not a pure module)"
+  }
+];
+var SettingsError = class extends Error {
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compile(pattern, flags, where) {
+  try {
+    return new RegExp(pattern, flags);
+  } catch (error) {
+    throw new SettingsError(
+      `${where}: invalid regular expression ${JSON.stringify(pattern)} (${error.message})`
+    );
+  }
+}
+function stringArray(value, where) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item === "")) {
+    throw new SettingsError(`${where}: must be an array of non-empty strings`);
+  }
+  return value;
+}
+function optionalString(value, where) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string" || value === "") {
+    throw new SettingsError(`${where}: must be a non-empty string`);
+  }
+  return value;
+}
+function rejectUnknownKeys(value, known, where) {
+  for (const key of Object.keys(value)) {
+    if (!known.includes(key)) {
+      throw new SettingsError(`${where}: unknown key ${JSON.stringify(key)}`);
+    }
+  }
+}
+function section(value, known, where) {
+  if (value === void 0) {
+    return {};
+  }
+  if (!isRecord2(value)) {
+    throw new SettingsError(`${where}: must be an object`);
+  }
+  rejectUnknownKeys(value, known, where);
+  return value;
+}
+function compileRules(defaults, raw, where, extraKeys = []) {
+  const config = section(raw, ["defaults", "add", ...extraKeys], where);
+  if (config.defaults !== void 0 && typeof config.defaults !== "boolean") {
+    throw new SettingsError(`${where}.defaults: must be a boolean`);
+  }
+  const added = config.add ?? [];
+  if (!Array.isArray(added)) {
+    throw new SettingsError(`${where}.add: must be an array`);
+  }
+  const all = [];
+  if (config.defaults !== false) {
+    defaults.forEach((rule) => all.push({ rule, where: `${where} (default)` }));
+  }
+  added.forEach((item, index) => {
+    const at = `${where}.add[${index}]`;
+    if (typeof item === "string" && item !== "") {
+      all.push({ rule: { pattern: item }, where: at });
+      return;
+    }
+    if (!isRecord2(item) || typeof item.pattern !== "string" || item.pattern === "") {
+      throw new SettingsError(`${at}: must be a pattern string or { pattern, flags?, reason? }`);
+    }
+    rejectUnknownKeys(item, ["pattern", "flags", "reason"], at);
+    if (item.flags !== void 0 && typeof item.flags !== "string") {
+      throw new SettingsError(`${at}.flags: must be a string`);
+    }
+    if (item.reason !== void 0 && typeof item.reason !== "string") {
+      throw new SettingsError(`${at}.reason: must be a string`);
+    }
+    all.push({ rule: item, where: at });
+  });
+  return {
+    rules: all.map(({ rule, where: at }) => ({
+      regex: compile(rule.pattern, rule.flags, at),
+      reason: rule.reason ?? `matches ${rule.pattern}`
+    })),
+    section: config
+  };
+}
+function resolveSettings(raw) {
+  const settings = section(
+    raw,
+    [
+      "gateExtensions",
+      "spec",
+      "impureImports",
+      "impureNamedImports",
+      "impurePaths",
+      "forbiddenSource",
+      "importAliases",
+      "gateCommand",
+      "selfcheck",
+      "stryker",
+      "lcov"
+    ],
+    "settings"
+  );
+  const gateExtensions = settings.gateExtensions === void 0 ? DEFAULT_GATE_EXTENSIONS : stringArray(settings.gateExtensions, "settings.gateExtensions");
+  if (gateExtensions.length === 0 || gateExtensions.some((ext) => !ext.startsWith("."))) {
+    throw new SettingsError(
+      'settings.gateExtensions: must list at least one extension starting with "."'
+    );
+  }
+  const spec = section(settings.spec, ["suffixes", "rewrite"], "settings.spec");
+  const specSuffixes = spec.suffixes === void 0 ? null : stringArray(spec.suffixes, "settings.spec.suffixes");
+  const rewriteRaw = spec.rewrite ?? [];
+  if (!Array.isArray(rewriteRaw)) {
+    throw new SettingsError("settings.spec.rewrite: must be an array");
+  }
+  const specRewrite = rewriteRaw.map((item, index) => {
+    const at = `settings.spec.rewrite[${index}]`;
+    if (!isRecord2(item) || typeof item.from !== "string" || typeof item.to !== "string") {
+      throw new SettingsError(`${at}: must be { from, to }`);
+    }
+    rejectUnknownKeys(item, ["from", "to"], at);
+    return { regex: compile(item.from, void 0, at), to: item.to };
+  });
+  const imports = compileRules(
+    DEFAULT_IMPURE_IMPORTS,
+    settings.impureImports,
+    "settings.impureImports",
+    ["allow"]
+  );
+  const allowedImports = imports.section.allow === void 0 ? [] : stringArray(imports.section.allow, "settings.impureImports.allow").map(
+    (pattern, index) => compile(pattern, void 0, `settings.impureImports.allow[${index}]`)
+  );
+  const named = section(
+    settings.impureNamedImports,
+    ["defaults", "add"],
+    "settings.impureNamedImports"
+  );
+  if (named.defaults !== void 0 && typeof named.defaults !== "boolean") {
+    throw new SettingsError("settings.impureNamedImports.defaults: must be a boolean");
+  }
+  const namedAdd = named.add ?? [];
+  if (!Array.isArray(namedAdd)) {
+    throw new SettingsError("settings.impureNamedImports.add: must be an array");
+  }
+  const impureNamedImports = [
+    ...named.defaults === false ? [] : DEFAULT_IMPURE_NAMED_IMPORTS,
+    ...namedAdd.map((item, index) => {
+      const at = `settings.impureNamedImports.add[${index}]`;
+      if (!isRecord2(item) || typeof item.module !== "string" || item.module === "") {
+        throw new SettingsError(`${at}: must be { module, names, reason? }`);
+      }
+      rejectUnknownKeys(item, ["module", "names", "reason"], at);
+      const names = stringArray(item.names, `${at}.names`);
+      if (names.length === 0) {
+        throw new SettingsError(`${at}.names: must list at least one name`);
+      }
+      if (item.reason !== void 0 && typeof item.reason !== "string") {
+        throw new SettingsError(`${at}.reason: must be a string`);
+      }
+      return {
+        module: item.module,
+        names,
+        reason: item.reason ?? "not allowed in a pure module"
+      };
+    })
+  ];
+  const aliasesRaw = settings.importAliases ?? [];
+  if (!Array.isArray(aliasesRaw)) {
+    throw new SettingsError("settings.importAliases: must be an array");
+  }
+  const importAliases = aliasesRaw.map((item, index) => {
+    const at = `settings.importAliases[${index}]`;
+    if (!isRecord2(item) || typeof item.prefix !== "string" || item.prefix === "" || typeof item.target !== "string") {
+      throw new SettingsError(`${at}: must be { prefix, target }`);
+    }
+    rejectUnknownKeys(item, ["prefix", "target"], at);
+    return { prefix: item.prefix, target: item.target };
+  });
+  let gateCommand = null;
+  if (settings.gateCommand !== void 0) {
+    gateCommand = stringArray(settings.gateCommand, "settings.gateCommand");
+    if (gateCommand.length === 0) {
+      throw new SettingsError("settings.gateCommand: must not be empty");
+    }
+  }
+  const selfcheck = section(settings.selfcheck, ["mode", "failurePattern"], "settings.selfcheck");
+  if (selfcheck.mode !== void 0 && selfcheck.mode !== "all" && selfcheck.mode !== "first") {
+    throw new SettingsError('settings.selfcheck.mode: must be "all" or "first"');
+  }
+  const selfcheckFailurePattern = optionalString(
+    selfcheck.failurePattern,
+    "settings.selfcheck.failurePattern"
+  );
+  if (selfcheckFailurePattern !== null) {
+    compile(
+      selfcheckFailurePattern.split("{gate}").join("x"),
+      void 0,
+      "settings.selfcheck.failurePattern"
+    );
+  }
+  const stryker = section(settings.stryker, ["configFile", "reportFile"], "settings.stryker");
+  const lcov = section(settings.lcov, ["file", "summaryExclude"], "settings.lcov");
+  return {
+    gateExtensions,
+    specSuffixes,
+    specRewrite,
+    impureImports: imports.rules,
+    allowedImports,
+    impureNamedImports,
+    impurePaths: compileRules(DEFAULT_IMPURE_PATHS, settings.impurePaths, "settings.impurePaths").rules,
+    forbiddenSource: compileRules(
+      DEFAULT_FORBIDDEN_SOURCE,
+      settings.forbiddenSource,
+      "settings.forbiddenSource"
+    ).rules,
+    importAliases,
+    gateCommand,
+    selfcheckMode: selfcheck.mode ?? "all",
+    selfcheckFailurePattern,
+    strykerConfigFile: optionalString(stryker.configFile, "settings.stryker.configFile"),
+    strykerReportFile: optionalString(stryker.reportFile, "settings.stryker.reportFile") ?? DEFAULT_REPORT_FILE,
+    lcovFile: optionalString(lcov.file, "settings.lcov.file"),
+    lcovSummaryExclude: lcov.summaryExclude === void 0 ? [] : stringArray(lcov.summaryExclude, "settings.lcov.summaryExclude").map(
+      (pattern, index) => compile(pattern, void 0, `settings.lcov.summaryExclude[${index}]`)
+    )
+  };
+}
+
+// src/core/selfcheck.ts
+var EXCLUDE_ENV = "TEST_GATES_EXCLUDE_SPEC";
+var THRESHOLD_MESSAGE = /threshold|coverage data for/i;
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function judgeSelfcheck(input) {
+  const { status, output, gatePath } = input;
+  if (status === null) {
+    return "the gate command did not run to completion";
+  }
+  if (status === 0) {
+    return `the gate passed although the spec of ${gatePath} was left out. The gate does not measure this file (does the gate config honor ${EXCLUDE_ENV}?)`;
+  }
+  if (input.failurePattern) {
+    const pattern = input.failurePattern.split("{gate}").join(escapeRegExp(gatePath));
+    return new RegExp(pattern).test(output) ? null : `the gate failed (exit ${status}) but the output does not match settings.selfcheck.failurePattern`;
+  }
+  const reported = output.split("\n").some((line) => line.includes(gatePath) && THRESHOLD_MESSAGE.test(line));
+  return reported ? null : `the gate failed (exit ${status}) but not on the coverage threshold of ${gatePath}. It may be failing for another reason`;
+}
+
+// src/core/spec-path.ts
+function gateExtensionOf(gatePath, gateExtensions) {
+  const matching = gateExtensions.filter((extension) => gatePath.endsWith(extension)).sort((a, b) => b.length - a.length);
+  return matching[0] ?? null;
+}
+function suffixesFor(extension, settings) {
+  return settings.specSuffixes ?? [`.spec${extension}`, `.test${extension}`];
+}
+function specCandidatesFor(gatePath, settings) {
+  const extension = gateExtensionOf(gatePath, settings.gateExtensions);
+  if (extension === null) {
+    return [];
+  }
+  let base = gatePath.slice(0, -extension.length);
+  for (const { regex, to } of settings.specRewrite) {
+    base = base.replace(regex, to);
+  }
+  return suffixesFor(extension, settings).map((suffix) => base + suffix);
+}
+function looksLikeSpec(gatePath, settings) {
+  const extension = gateExtensionOf(gatePath, settings.gateExtensions);
+  return extension !== null && suffixesFor(extension, settings).some((suffix) => gatePath.endsWith(suffix));
+}
+
+// src/fs.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function existsExact(rootDir, relativePath, kind = "file") {
+  let current = rootDir;
+  for (const segment of relativePath.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(current);
+    } catch {
+      return false;
+    }
+    if (!entries.includes(segment)) {
+      return false;
+    }
+    current = import_node_path.default.join(current, segment);
+  }
+  try {
+    return kind === "any" || import_node_fs.default.statSync(current).isFile();
+  } catch {
+    return false;
+  }
+}
+function readText(rootDir, relativePath) {
+  return import_node_fs.default.readFileSync(import_node_path.default.join(rootDir, relativePath), "utf8");
+}
+
+// src/load.ts
+function readManifest(dir) {
+  const absoluteDir = import_node_path2.default.resolve(dir);
+  const manifestPath = import_node_path2.default.join(absoluteDir, MANIFEST_FILE);
+  let text;
+  try {
+    text = import_node_fs2.default.readFileSync(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ManifestError(`${MANIFEST_FILE} not found in ${absoluteDir}`);
+    }
+    throw new ManifestError(`cannot read ${manifestPath}: ${error.message}`);
+  }
+  const parsed = parseManifest(text);
+  let settings;
+  try {
+    settings = resolveSettings(parsed.settings);
+  } catch (error) {
+    if (error instanceof SettingsError) {
+      throw new ManifestError(`${MANIFEST_FILE}: ${error.message}`);
+    }
+    throw error;
+  }
+  const gates = parsed.gates.map((gate) => {
+    const specCandidates = specCandidatesFor(gate.path, settings);
+    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    return {
+      ...gate,
+      specCandidates,
+      existingSpecs,
+      spec: existingSpecs[0] ?? specCandidates[0] ?? null
+    };
+  });
+  return {
+    dir: absoluteDir,
+    gates,
+    candidates: parsed.candidates,
+    settings,
+    violations: parsed.violations
+  };
+}
+function loadGates(dir = process.cwd()) {
+  const manifest = readManifest(dir);
+  if (manifest.violations.length > 0) {
+    throw new ManifestError(
+      `${MANIFEST_FILE} has problems (run "test-gates check"):
+` + manifest.violations.map((violation) => `  - ${violation.message}`).join("\n")
+    );
+  }
+  return manifest;
+}
+function gateSpecs(manifest, env = process.env) {
+  const excluded = env[EXCLUDE_ENV];
+  return manifest.gates.map((gate) => gate.spec).filter((spec) => spec !== null && spec !== excluded);
+}
+
+// src/commands/check.ts
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+
+// src/core/imports.ts
+var FROM_STATEMENT = /(?:^|[\n;])[ \t]*(import|export)\s+(type\s+)?([\w$\s,{}*]*?)\s*\bfrom\s*(['"])([^'"\n]+)\4/g;
+var SIDE_EFFECT_IMPORT = /(?:^|[\n;])[ \t]*import\s*(['"])([^'"\n]+)\1/g;
+var CALL_IMPORT = /\b(?:require|import)\s*\(\s*(['"`])([^'"`\n]+)\1\s*\)/g;
+function lineAt(source, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (source[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+function parseImports(source) {
+  const found = [];
+  for (const match of source.matchAll(FROM_STATEMENT)) {
+    const clause = match[3];
+    const module2 = match[5];
+    const braces = /\{([^}]*)\}/.exec(clause);
+    const names = braces ? braces[1].split(",").map((part) => part.trim()).filter((part) => part !== "" && !/^type\s/.test(part)).map((part) => part.split(/\s+as\s+/)[0].trim()) : [];
+    const outsideBraces = clause.replace(/\{[^}]*\}/, "").replace(/,/g, "").trim();
+    found.push({
+      module: module2,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module2)),
+      typeOnly: match[2] !== void 0,
+      names,
+      whole: outsideBraces !== ""
+    });
+  }
+  for (const match of source.matchAll(SIDE_EFFECT_IMPORT)) {
+    const module2 = match[2];
+    found.push({
+      module: module2,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module2)),
+      typeOnly: false,
+      names: [],
+      whole: false
+    });
+  }
+  for (const match of source.matchAll(CALL_IMPORT)) {
+    const module2 = match[2];
+    found.push({
+      module: module2,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module2)),
+      typeOnly: false,
+      names: [],
+      whole: true
+    });
+  }
+  return found.sort((a, b) => a.line - b.line);
+}
+
+// src/core/scan.ts
+var IGNORE_DIRECTIVE = /\b(istanbul|c8|v8)\s+ignore\b/;
+var DECORATOR = /^\s*@[A-Za-z_$][\w$.]*\s*\(/;
+var STRYKER_COMMENT = /Stryker\s+(disable|restore)\b/;
+var DISABLED_TESTS = [
+  { regex: /\.\s*(skip|only|todo)\b/, label: ".skip / .only / .todo" },
+  {
+    regex: /\b(?:describe|it|test|suite)(?:\s*\.\s*\w+)*\s*\.\s*(?:skipIf|runIf|fails)\b/,
+    label: ".skipIf / .runIf / .fails"
+  },
+  {
+    regex: /\b(xit|xtest|xdescribe|fit|fdescribe)\s*[.(]/,
+    label: "xit / xtest / xdescribe / fit / fdescribe"
+  }
+];
+var MODULE_MOCK = /\b(?:jest|vi)\s*\.\s*(?:mock|doMock|unstable_mockModule|setMock)\s*\(\s*(?:import\s*\(\s*)?(['"`])([^'"`\n]+)\1/g;
+var SCRIPT_EXTENSION = /\.[cm]?[jt]sx?$/;
+function eachLine(source, visit) {
+  source.split("\n").forEach((line, index) => visit(line, index + 1));
+}
+function escapeRegExp2(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function scanGateSource(gatePath, source, settings) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    if (DECORATOR.test(line)) {
+      violations.push({
+        file: gatePath,
+        line: lineNumber,
+        message: "decorator found (not a pure module). Move the file to candidates"
+      });
+    }
+    if (IGNORE_DIRECTIVE.test(line)) {
+      violations.push({ file: gatePath, line: lineNumber, message: "coverage ignore directive" });
+    }
+    if (STRYKER_COMMENT.test(line)) {
+      violations.push({
+        file: gatePath,
+        line: lineNumber,
+        message: "Stryker comment (disable / restore). Allow an equivalent mutant in test-gates.json (equivalentMutants) instead"
+      });
+    }
+    for (const rule of settings.forbiddenSource) {
+      if (rule.regex.test(line)) {
+        violations.push({ file: gatePath, line: lineNumber, message: rule.reason });
+      }
+    }
+  });
+  for (const imported of parseImports(source)) {
+    if (imported.typeOnly) {
+      continue;
+    }
+    if (!settings.allowedImports.some((regex) => regex.test(imported.module))) {
+      for (const rule of settings.impureImports) {
+        if (rule.regex.test(imported.module)) {
+          violations.push({
+            file: gatePath,
+            line: imported.line,
+            message: `runtime import of "${imported.module}" (${rule.reason})`
+          });
+        }
+      }
+    }
+    for (const rule of settings.impureNamedImports) {
+      if (imported.module !== rule.module) {
+        continue;
+      }
+      const hit = rule.names.filter(
+        (name) => imported.names.includes(name) || imported.whole && new RegExp(`\\b${escapeRegExp2(name)}\\b`).test(source)
+      );
+      if (hit.length > 0) {
+        violations.push({
+          file: gatePath,
+          line: imported.line,
+          message: `runtime use of ${hit.join(", ")} from "${rule.module}" (${rule.reason})`
+        });
+      }
+    }
+  }
+  return violations.sort((a, b) => a.line - b.line);
+}
+function resolveSpecifier(specifier, fromFile, aliases) {
+  let joined = null;
+  if (specifier.startsWith(".")) {
+    const directory = fromFile.includes("/") ? fromFile.slice(0, fromFile.lastIndexOf("/")) : "";
+    joined = directory === "" ? specifier : `${directory}/${specifier}`;
+  } else {
+    for (const alias of aliases) {
+      if (specifier.startsWith(alias.prefix)) {
+        joined = alias.target + specifier.slice(alias.prefix.length);
+        break;
+      }
+    }
+  }
+  if (joined === null) {
+    return null;
+  }
+  const segments = [];
+  for (const segment of joined.split("/")) {
+    if (segment === "..") {
+      segments.pop();
+    } else if (segment !== "." && segment !== "") {
+      segments.push(segment);
+    }
+  }
+  return segments.join("/").replace(SCRIPT_EXTENSION, "");
+}
+function scanSpecSource(gatePath, specPath, source, settings) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    if (IGNORE_DIRECTIVE.test(line)) {
+      violations.push({ file: specPath, line: lineNumber, message: "coverage ignore directive" });
+    }
+    for (const { regex, label } of DISABLED_TESTS) {
+      if (regex.test(line)) {
+        violations.push({
+          file: specPath,
+          line: lineNumber,
+          message: `${label} (a skipped or focused test)`
+        });
+      }
+    }
+  });
+  const gateModule = gatePath.replace(SCRIPT_EXTENSION, "");
+  const gateDirectory = gateModule.replace(/\/index$/, "");
+  for (const match of source.matchAll(MODULE_MOCK)) {
+    const specifier = match[2];
+    const resolved = resolveSpecifier(specifier, specPath, settings.importAliases);
+    if (resolved === gateModule || resolved === gateDirectory) {
+      let line = 1;
+      for (let i = 0; i < match.index; i += 1) {
+        if (source[i] === "\n") {
+          line += 1;
+        }
+      }
+      violations.push({
+        file: specPath,
+        line,
+        message: `mocks the module under test ("${specifier}")`
+      });
+    }
+  }
+  return violations.sort((a, b) => a.line - b.line);
+}
+var STRYKER_WEAKENING = /\b(excludedMutations|ignoreStatic|ignorers)\b/;
+function scanStrykerConfig(configPath, source) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    const match = STRYKER_WEAKENING.exec(line);
+    if (match) {
+      violations.push({
+        file: configPath,
+        line: lineNumber,
+        message: `${match[1]} takes mutants out of the evaluation. Allow equivalent mutants one by one in test-gates.json instead`
+      });
+    }
+  });
+  return violations;
+}
+
+// src/commands/check.ts
+var STRYKER_CONFIG_NAMES = [
+  "stryker.gates.config.mjs",
+  "stryker.gates.config.js",
+  "stryker.gates.config.cjs",
+  "stryker.gates.config.json"
+];
+function findStrykerConfig(manifest) {
+  if (manifest.settings.strykerConfigFile !== null) {
+    return manifest.settings.strykerConfigFile;
+  }
+  return STRYKER_CONFIG_NAMES.find((name) => import_node_fs3.default.existsSync(import_node_path3.default.join(manifest.dir, name))) ?? null;
+}
+function isPlainRelativePath(file) {
+  return !import_node_path3.default.isAbsolute(file) && !/^[A-Za-z]:/.test(file) && !file.includes("\\") && !file.split("/").some((segment) => segment === ".." || segment === "." || segment === "");
+}
+function checkGates(manifest) {
+  const { dir, settings } = manifest;
+  const violations = [...manifest.violations];
+  for (const gate of manifest.gates) {
+    if (!isPlainRelativePath(gate.path)) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${gate.path}: write the path relative to the subproject, with "/" and without ".."`
+      });
+      continue;
+    }
+    if (gateExtensionOf(gate.path, settings.gateExtensions) === null) {
+      violations.push({
+        file: gate.path,
+        message: `a gate must be one of ${settings.gateExtensions.join(" / ")} (settings.gateExtensions)`
+      });
+      continue;
+    }
+    if (looksLikeSpec(gate.path, settings)) {
+      violations.push({ file: gate.path, message: "a spec cannot be a gate" });
+      continue;
+    }
+    for (const rule of settings.impurePaths) {
+      if (rule.regex.test(gate.path)) {
+        violations.push({
+          file: gate.path,
+          message: `cannot be a gate (${rule.reason}). Move it to candidates`
+        });
+      }
+    }
+    if (!existsExact(dir, gate.path)) {
+      violations.push({
+        file: gate.path,
+        message: "file not found (the check is case-sensitive)"
+      });
+      continue;
+    }
+    violations.push(...scanGateSource(gate.path, readText(dir, gate.path), settings));
+    if (gate.specCandidates.length === 0) {
+      continue;
+    }
+    if (gate.existingSpecs.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: `spec not found (looked for ${gate.specCandidates.join(", ")}; the check is case-sensitive)`
+      });
+      continue;
+    }
+    if (gate.existingSpecs.length > 1) {
+      violations.push({
+        file: gate.path,
+        message: `more than one spec (${gate.existingSpecs.join(", ")}). Keep one, or narrow settings.spec.suffixes`
+      });
+      continue;
+    }
+    const specPath = gate.existingSpecs[0];
+    violations.push(...scanSpecSource(gate.path, specPath, readText(dir, specPath), settings));
+  }
+  for (const candidate of manifest.candidates) {
+    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any")) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${candidate.path}: candidate not found. Remove it, or fix the path`
+      });
+    }
+  }
+  const strykerConfig = findStrykerConfig(manifest);
+  if (strykerConfig !== null) {
+    if (!import_node_fs3.default.existsSync(import_node_path3.default.join(dir, strykerConfig))) {
+      violations.push({ file: strykerConfig, message: "Stryker config not found" });
+    } else {
+      violations.push(...scanStrykerConfig(strykerConfig, readText(dir, strykerConfig)));
+    }
+  }
+  return violations;
+}
+
+// src/core/mutation-result.ts
+var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
+var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
+function normalizeCode(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizePath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function sliceByLocation(source, location) {
+  const lines = source.split("\n");
+  const { start, end } = location;
+  const first = lines[start.line - 1];
+  const last = lines[end.line - 1];
+  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+    return null;
+  }
+  if (start.line === end.line) {
+    return first.slice(start.column - 1, end.column - 1);
+  }
+  return [
+    first.slice(start.column - 1),
+    ...lines.slice(start.line, end.line - 1),
+    last.slice(0, end.column - 1)
+  ].join("\n");
+}
+function keyOf(mutator, original, replacement) {
+  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+}
+function describeAllowance(entry) {
+  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
+  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+}
+function judgeMutationReport(input) {
+  const violations = [];
+  const survivors = [];
+  const summary = {
+    total: 0,
+    detected: 0,
+    timeout: 0,
+    allowed: 0,
+    notEvaluable: 0,
+    unallowed: 0
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, result] of Object.entries(input.report.files ?? {})) {
+    files.set(normalizePath(file), result);
+  }
+  for (const gate of input.gates) {
+    const gatePath = normalizePath(gate.path);
+    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
+    violations.push(...shapeViolations);
+    const allowances = Array.isArray(gate.equivalentMutants) ? gate.equivalentMutants : [];
+    const result = files.get(gatePath);
+    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: "no mutants in the report (the gate was not mutation tested)"
+      });
+      continue;
+    }
+    const diskSource = input.readSource(gate.path);
+    const source = result.source ?? diskSource;
+    if (source === void 0) {
+      violations.push({
+        file: gate.path,
+        message: "source is neither in the report nor readable on disk"
+      });
+      continue;
+    }
+    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
+      violations.push({
+        file: gate.path,
+        message: "the report was made from a different version of this file. Run Stryker again"
+      });
+      continue;
+    }
+    const located = [];
+    const byKey = /* @__PURE__ */ new Map();
+    const sorted = [...result.mutants].sort(
+      (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
+    );
+    let locationsValid = true;
+    for (const mutant of sorted) {
+      const original = sliceByLocation(normalizeNewlines(source), mutant.location);
+      if (original === null) {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
+        });
+        locationsValid = false;
+        continue;
+      }
+      const replacement = mutant.replacement ?? "";
+      const key = keyOf(mutant.mutatorName, original, replacement);
+      const group = byKey.get(key) ?? [];
+      const entry = {
+        mutant,
+        original,
+        replacement,
+        occurrence: group.length + 1,
+        sameKeyCount: 0
+      };
+      group.push(entry);
+      byKey.set(key, group);
+      located.push(entry);
+    }
+    for (const group of byKey.values()) {
+      for (const entry of group) {
+        entry.sameKeyCount = group.length;
+      }
+    }
+    if (!locationsValid) {
+      continue;
+    }
+    const allowed = /* @__PURE__ */ new Set();
+    allowances.forEach((allowance, index) => {
+      if (!isUsableEquivalentMutant(allowance)) {
+        return;
+      }
+      const at = `${gate.path}: equivalentMutants[${index}] (${describeAllowance(allowance)})`;
+      const group = byKey.get(keyOf(allowance.mutator, allowance.original, allowance.replacement)) ?? [];
+      if (allowance.occurrence === void 0 && group.length > 1) {
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
+        });
+        return;
+      }
+      const target = group[(allowance.occurrence ?? 1) - 1];
+      if (!target || !SURVIVED.has(target.mutant.status)) {
+        const why = target ? `the mutant is now ${target.mutant.status}` : "no such mutant in this run";
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${at}: stale allowance (${why}). Remove it`
+        });
+        return;
+      }
+      if (allowed.has(target)) {
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${at}: another allowance already covers this mutant`
+        });
+        return;
+      }
+      allowed.add(target);
+    });
+    for (const entry of located) {
+      const { mutant } = entry;
+      summary.total += 1;
+      if (DETECTED.has(mutant.status)) {
+        summary.detected += 1;
+        if (mutant.status === "Timeout") {
+          summary.timeout += 1;
+        }
+      } else if (NOT_EVALUABLE.has(mutant.status)) {
+        summary.notEvaluable += 1;
+      } else if (SURVIVED.has(mutant.status)) {
+        if (allowed.has(entry)) {
+          summary.allowed += 1;
+          continue;
+        }
+        summary.unallowed += 1;
+        survivors.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          column: mutant.location.start.column,
+          status: mutant.status,
+          mutator: mutant.mutatorName,
+          original: normalizeCode(entry.original),
+          replacement: normalizeCode(entry.replacement),
+          occurrence: entry.occurrence,
+          sameKeyCount: entry.sameKeyCount,
+          allowance: {
+            mutator: mutant.mutatorName,
+            original: normalizeCode(entry.original),
+            replacement: normalizeCode(entry.replacement),
+            ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
+            reason: ""
+          }
+        });
+      } else {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
+        });
+      }
+    }
+  }
+  if (summary.total === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "no mutants were evaluated (the mutation test ran on nothing)"
+    });
+  }
+  return { violations, survivors, summary };
+}
+function formatSurvivor(survivor) {
+  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
+  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+}
+function formatSummary(summary) {
+  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+}
+
+// src/core/lcov.ts
+function normalizePath2(file, rootDir) {
+  let normalized = file.replace(/\\/g, "/");
+  if (rootDir !== void 0) {
+    const root = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized.startsWith(`${root}/`)) {
+      normalized = normalized.slice(root.length + 1);
+    }
+  }
+  return normalized.replace(/^\.\//, "");
+}
+function parseLcov(text, rootDir) {
+  const files = /* @__PURE__ */ new Map();
+  let record = null;
+  const closeRecord = () => {
+    if (record && !record.hasDa) {
+      record.file.found += record.found;
+      record.file.hit += record.hit;
+    }
+    record = null;
+  };
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line.startsWith("SF:")) {
+      closeRecord();
+      const path4 = normalizePath2(line.slice(3), rootDir);
+      const file = files.get(path4) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path4, file);
+      record = { file, hasDa: false, found: 0, hit: 0 };
+    } else if (line === "end_of_record") {
+      closeRecord();
+    } else if (record) {
+      const open = record;
+      if (line.startsWith("DA:")) {
+        const [lineNumber, hits] = line.slice(3).split(",");
+        const number = Number(lineNumber);
+        const count = Number(hits);
+        if (Number.isInteger(number) && Number.isFinite(count)) {
+          open.hasDa = true;
+          open.file.lines.set(number, Math.max(open.file.lines.get(number) ?? 0, count));
+        }
+      } else if (line.startsWith("LF:")) {
+        open.found = Number(line.slice(3)) || 0;
+      } else if (line.startsWith("LH:")) {
+        open.hit = Number(line.slice(3)) || 0;
+      }
+    }
+  }
+  closeRecord();
+  const result = /* @__PURE__ */ new Map();
+  for (const [file, accumulator] of files) {
+    const uncovered = [...accumulator.lines.entries()].filter(([, hits]) => hits <= 0).map(([lineNumber]) => lineNumber).sort((a, b) => a - b);
+    result.set(file, {
+      found: accumulator.lines.size + accumulator.found,
+      hit: accumulator.lines.size - uncovered.length + accumulator.hit,
+      uncovered
+    });
+  }
+  return result;
+}
+function judgeLcov(gatePaths, coverage) {
+  const violations = [];
+  const results = [];
+  for (const gatePath of gatePaths) {
+    const file = coverage.get(normalizePath2(gatePath));
+    if (!file) {
+      violations.push({ file: gatePath, message: "no record in the lcov file" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    if (file.found === 0) {
+      violations.push({ file: gatePath, message: "no instrumented lines in the lcov record" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    const ok = file.hit === file.found;
+    if (!ok) {
+      const shown = file.uncovered.slice(0, 20).join(", ");
+      const more = file.uncovered.length > 20 ? ", \u2026" : "";
+      violations.push({
+        file: gatePath,
+        ...file.uncovered[0] === void 0 ? {} : { line: file.uncovered[0] },
+        message: `${file.hit}/${file.found} lines covered` + (shown === "" ? "" : ` (uncovered: ${shown}${more})`)
+      });
+    }
+    results.push({ path: gatePath, found: file.found, hit: file.hit, ok });
+  }
+  return { violations, results };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_FORBIDDEN_SOURCE,
+  DEFAULT_GATE_EXTENSIONS,
+  DEFAULT_IMPURE_IMPORTS,
+  DEFAULT_IMPURE_NAMED_IMPORTS,
+  DEFAULT_IMPURE_PATHS,
+  DEFAULT_REPORT_FILE,
+  EXCLUDE_ENV,
+  MANIFEST_FILE,
+  ManifestError,
+  checkGates,
+  formatSummary,
+  formatSurvivor,
+  gateSpecs,
+  judgeLcov,
+  judgeMutationReport,
+  judgeSelfcheck,
+  loadGates,
+  normalizeCode,
+  parseLcov,
+  parseManifest,
+  readManifest,
+  resolveSettings,
+  sliceByLocation
+});