@monorepolint/rules 0.5.0-alpha.103 → 0.5.0-alpha.106

package/build/js/index.cjs

@@ -1,1491 +0,0 @@
-"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(
-  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 src_exports = {};
-__export(src_exports, {
-  AlphabeticalDependencies: () => AlphabeticalDependencies,
-  AlphabeticalScripts: () => AlphabeticalScripts,
-  BannedDependencies: () => BannedDependencies,
-  ConsistentDependencies: () => ConsistentDependencies,
-  ConsistentVersions: () => ConsistentVersions,
-  FileContents: () => FileContents,
-  MustSatisfyPeerDependencies: () => MustSatisfyPeerDependencies,
-  NestedWorkspaces: () => NestedWorkspaces,
-  PackageEntry: () => PackageEntry,
-  PackageOrder: () => PackageOrder,
-  PackageScript: () => PackageScript,
-  RequireDependency: () => RequireDependency,
-  StandardTsConfig: () => StandardTsConfig,
-  alphabeticalDependencies: () => alphabeticalDependencies,
-  alphabeticalScripts: () => alphabeticalScripts,
-  bannedDependencies: () => bannedDependencies,
-  consistentDependencies: () => consistentDependencies,
-  consistentVersions: () => consistentVersions,
-  fileContents: () => fileContents,
-  mustSatisfyPeerDependencies: () => mustSatisfyPeerDependencies,
-  nestedWorkspaces: () => nestedWorkspaces,
-  packageEntry: () => packageEntry,
-  packageOrder: () => packageOrder,
-  packageScript: () => packageScript,
-  requireDependency: () => requireDependency,
-  standardTsconfig: () => standardTsconfig
-});
-module.exports = __toCommonJS(src_exports);
-
-// src/alphabeticalDependencies.ts
-var r = __toESM(require("runtypes"), 1);
-
-// src/util/checkAlpha.ts
-var import_jest_diff = require("jest-diff");
-function checkAlpha(context, block) {
-  const packageJson = context.getPackageJson();
-  const packagePath = context.getPackageJsonPath();
-  const blockToSort = packageJson[block];
-  if (blockToSort === void 0) {
-    return;
-  }
-  const actualOrder = Object.keys(blockToSort);
-  const expectedOrder = actualOrder.slice().sort();
-  if (!arrayOrderCompare(actualOrder, expectedOrder)) {
-    context.addError({
-      file: packagePath,
-      message: createIncorrectOrderErrorMessage(block, packageJson.name),
-      longMessage: (0, import_jest_diff.diff)(expectedOrder, actualOrder, { expand: true }),
-      fixer: () => {
-        const expectedDependencies = {};
-        expectedOrder.forEach((dep) => {
-          expectedDependencies[dep] = blockToSort[dep];
-        });
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
-        context.host.writeJson(packagePath, newPackageJson);
-      }
-    });
-  }
-}
-function arrayOrderCompare(a, b) {
-  for (let index = 0; index < a.length; index++) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
-  return true;
-}
-function createIncorrectOrderErrorMessage(block, packageName) {
-  return `Incorrect order of ${block} in ${packageName}'s package.json`;
-}
-
-// src/util/createNewRuleConversion.ts
-var id = 0;
-var NewRuleConverterBase = class {
-  constructor(name, checkFunc, optionsRuntype, ruleEntry) {
-    this.name = name;
-    this.checkFunc = checkFunc;
-    this.optionsRuntype = optionsRuntype;
-    this.ruleEntry = ruleEntry;
-    this.check = (context) => this.checkFunc(context, this.ruleEntry.options, { id: this.id });
-    this.options = ruleEntry.options;
-    this.id = `${this.name} :: ${id++}`;
-  }
-};
-function createNewRuleConversion(name, old) {
-  return class NewRule extends NewRuleConverterBase {
-    constructor(ruleEntry) {
-      super(name, old.check, old.optionsRuntype, ruleEntry);
-    }
-  };
-}
-
-// src/alphabeticalDependencies.ts
-var Options = r.Undefined;
-var alphabeticalDependencies = {
-  check: function expectAlphabeticalDependencies(context) {
-    checkAlpha(context, "dependencies");
-    checkAlpha(context, "devDependencies");
-    checkAlpha(context, "peerDependencies");
-  },
-  optionsRuntype: Options
-};
-var AlphabeticalDependencies = createNewRuleConversion("AlphabetialDependencies", alphabeticalDependencies);
-
-// src/alphabeticalScripts.ts
-var r2 = __toESM(require("runtypes"), 1);
-var Options2 = r2.Undefined;
-var alphabeticalScripts = {
-  check: function expectAlphabeticalScripts(context) {
-    checkAlpha(context, "scripts");
-  },
-  optionsRuntype: Options2
-};
-var AlphabeticalScripts = createNewRuleConversion("AlphabeticalScripts", alphabeticalScripts);
-
-// src/bannedDependencies.ts
-var import_utils = require("@monorepolint/utils");
-var import_utils2 = require("@monorepolint/utils");
-var path2 = __toESM(require("path"), 1);
-var r3 = __toESM(require("runtypes"), 1);
-
-// src/util/packageDependencyGraphService.ts
-var path = __toESM(require("path"), 1);
-var import_resolve_package_path = __toESM(require("resolve-package-path"), 1);
-var PackageDependencyGraphService = class {
-  buildDependencyGraph(startPackageJsonPath, host, maxDepth) {
-    const nodes = /* @__PURE__ */ new Map();
-    const visit = (packageJsonPath, currentDepth) => {
-      if (nodes.has(packageJsonPath)) {
-        return nodes.get(packageJsonPath);
-      }
-      const packageJson = host.readJson(packageJsonPath);
-      const node = {
-        packageJson,
-        dependencies: /* @__PURE__ */ new Map(),
-        paths: {
-          packageJsonPath,
-          rootDirectory: path.dirname(packageJsonPath)
-        }
-      };
-      nodes.set(packageJsonPath, node);
-      const nextDepth = currentDepth + 1;
-      if (maxDepth == null || nextDepth <= maxDepth) {
-        const dependencies = packageJson.dependencies != null ? Object.keys(packageJson.dependencies) : [];
-        for (const dependency of dependencies) {
-          const dependencyPackageJsonPath = (0, import_resolve_package_path.default)(dependency, node.paths.rootDirectory);
-          if (dependencyPackageJsonPath == null) {
-            throw new Error(`Could not resolve ${dependency} from ${node.paths.rootDirectory}`);
-          }
-          node.dependencies.set(dependency, visit(dependencyPackageJsonPath, nextDepth));
-        }
-      }
-      return node;
-    };
-    return visit(startPackageJsonPath, 0);
-  }
-  *traverse(root, opts = { traverseAllPaths: false }) {
-    const visited = /* @__PURE__ */ new Set();
-    function* visit(node, importPath = []) {
-      if (!opts.traverseAllPaths && visited.has(node)) {
-        return;
-      }
-      if (importPath.indexOf(node) !== -1) {
-        return;
-      }
-      visited.add(node);
-      importPath = [...importPath, node];
-      yield { ...node, importPath };
-      for (const dependency of node.dependencies.values()) {
-        yield* visit(dependency, importPath);
-      }
-    }
-    yield* visit(root);
-  }
-};
-
-// src/bannedDependencies.ts
-var bannedDepGlobsField = r3.Union(
-  r3.Array(r3.String),
-  r3.Record({
-    glob: r3.Array(r3.String).optional(),
-    exact: r3.Array(r3.String).optional()
-  })
-);
-var Options3 = r3.Union(
-  r3.Record({
-    bannedDependencies: bannedDepGlobsField,
-    bannedTransitiveDependencies: r3.Undefined.optional()
-  }),
-  r3.Record({
-    bannedDependencies: bannedDepGlobsField.optional(),
-    bannedTransitiveDependencies: r3.Array(r3.String)
-  }),
-  r3.Record({
-    bannedDependencies: bannedDepGlobsField.optional(),
-    bannedTransitiveDependencies: r3.Array(r3.String).optional()
-  })
-);
-var setCache = /* @__PURE__ */ new Map();
-var aggregateTiming = new import_utils2.AggregateTiming(":bannedDependencies stats");
-var bannedDependencies = {
-  check: function expectAllowedDependencies(context, opts, extra) {
-    aggregateTiming.start(extra?.id ?? "unknown id");
-    const packageJson = context.getPackageJson();
-    const packagePath = context.getPackageJsonPath();
-    const curDeps = packageJson.dependencies && Object.keys(packageJson.dependencies);
-    const curDevDeps = packageJson.devDependencies && Object.keys(packageJson.devDependencies);
-    const curPeerDeps = packageJson.peerDependencies && Object.keys(packageJson.peerDependencies);
-    const { bannedDependencies: banned, bannedTransitiveDependencies: transitives } = opts;
-    const globs = banned && (Array.isArray(banned) ? banned : banned.glob);
-    const exacts = banned && (Array.isArray(banned) ? void 0 : banned.exact);
-    const violations = /* @__PURE__ */ new Set();
-    if (globs) {
-      if (curDeps)
-        populateProblemsGlobs(globs, curDeps, violations);
-      if (curDevDeps)
-        populateProblemsGlobs(globs, curDevDeps, violations);
-      if (curPeerDeps)
-        populateProblemsGlobs(globs, curPeerDeps, violations);
-    }
-    if (exacts) {
-      let set = setCache.get(exacts);
-      if (set === void 0) {
-        set = new Set(exacts);
-        setCache.set(exacts, set);
-      }
-      if (curDeps)
-        populateProblemsExact(set, curDeps, violations);
-      if (curDevDeps)
-        populateProblemsExact(set, curDevDeps, violations);
-      if (curPeerDeps)
-        populateProblemsExact(set, curPeerDeps, violations);
-    }
-    if (violations.size > 0) {
-      context.addError({
-        file: packagePath,
-        message: `Found ${violations.size} banned dependencies of package.json:
-	` + Array.from(violations).map((v) => `'${v}'`).join(", ")
-      });
-    }
-    if (transitives) {
-      let set = setCache.get(transitives);
-      if (set === void 0) {
-        set = new Set(transitives);
-        setCache.set(transitives, set);
-      }
-      checkTransitives(context, set);
-    }
-    aggregateTiming.stop();
-  },
-  optionsRuntype: Options3,
-  printStats: () => {
-    aggregateTiming.printResults();
-  }
-};
-var BannedDependencies = createNewRuleConversion("BannedDependencies", bannedDependencies);
-function populateProblemsExact(banned, dependencies, violations) {
-  for (const dependency of dependencies) {
-    if (banned.has(dependency)) {
-      violations.add(dependency);
-    }
-  }
-}
-function populateProblemsGlobs(bannedDependencyGlobs, dependencies, violations) {
-  for (const dependency of dependencies) {
-    if ((0, import_utils.matchesAnyGlob)(dependency, bannedDependencyGlobs)) {
-      violations.add(dependency);
-    }
-  }
-}
-function checkTransitives(context, banned) {
-  const graphService = new PackageDependencyGraphService();
-  const root = graphService.buildDependencyGraph(path2.resolve(context.getPackageJsonPath()), context.host);
-  for (const { dependencies, importPath } of graphService.traverse(root)) {
-    for (const [dependency] of dependencies) {
-      if (banned.has(dependency)) {
-        const [, ...importPathWithoutRoot] = importPath;
-        const pathing = [...importPathWithoutRoot.map(nameOrPackageJsonPath), dependency].join(" -> ");
-        context.addError({
-          file: root.paths.packageJsonPath,
-          message: `Banned transitive dependencies in repo: ${pathing}`
-        });
-      }
-    }
-  }
-}
-function nameOrPackageJsonPath(node) {
-  return node.packageJson.name ?? node.paths.packageJsonPath;
-}
-
-// src/consistentDependencies.ts
-var import_jest_diff2 = require("jest-diff");
-var r4 = __toESM(require("runtypes"), 1);
-var Options4 = r4.Record({
-  ignoredDependencies: r4.Array(r4.String).Or(r4.Undefined)
-}).Or(r4.Undefined);
-var skippedVersions = ["*", "latest"];
-var consistentDependencies = {
-  check: function expectConsistentDependencies(context, args) {
-    checkDeps(context, args, "dependencies");
-    checkDeps(context, args, "devDependencies");
-  },
-  optionsRuntype: Options4
-};
-var ConsistentDependencies = createNewRuleConversion("ConsistentDependencies", consistentDependencies);
-function checkDeps(context, args, block) {
-  const packageJson = context.getPackageJson();
-  const packagePath = context.getPackageJsonPath();
-  const dependencies = packageJson[block];
-  const workspacePackageJson = context.getWorkspaceContext().getPackageJson();
-  const workspaceDependencies = workspacePackageJson[block];
-  const ignoredDeps = args?.ignoredDependencies ?? [];
-  const depsToCheck = workspaceDependencies == null || ignoredDeps.length === 0 ? workspaceDependencies : omit(workspaceDependencies, ignoredDeps);
-  if (dependencies === void 0 || depsToCheck === void 0) {
-    return;
-  }
-  const expectedDependencies = {
-    ...dependencies,
-    ...filterKeys(depsToCheck, dependencies)
-  };
-  if (JSON.stringify(dependencies) !== JSON.stringify(expectedDependencies)) {
-    context.addError({
-      file: packagePath,
-      message: `Inconsistent ${block} with root in package.json`,
-      longMessage: (0, import_jest_diff2.diff)(expectedDependencies, dependencies, { expand: true }),
-      fixer: () => {
-        const newPackageJson = { ...packageJson };
-        newPackageJson[block] = expectedDependencies;
-        context.host.writeJson(packagePath, newPackageJson);
-      }
-    });
-  }
-}
-function filterKeys(ob, filterOb) {
-  const newOb = {};
-  for (const key of Object.keys(filterOb)) {
-    if (ob[key] !== void 0 && skippedVersions.indexOf(filterOb[key]) === -1) {
-      newOb[key] = ob[key];
-    }
-  }
-  return newOb;
-}
-function omit(obj, keysToOmit) {
-  const newObj = {};
-  const filtered = Object.entries(obj).filter(([key]) => !keysToOmit.includes(key));
-  for (const [key, value] of filtered) {
-    newObj[key] = value;
-  }
-  return newObj;
-}
-
-// src/consistentVersions.ts
-var import_utils3 = require("@monorepolint/utils");
-var r5 = __toESM(require("runtypes"), 1);
-var import_semver = require("semver");
-var Options5 = r5.Record({
-  matchDependencyVersions: r5.Dictionary(r5.Union(r5.String, r5.Array(r5.String)))
-});
-var consistentVersions = {
-  check: checkConsistentVersions,
-  optionsRuntype: Options5
-};
-function checkConsistentVersions(context, options) {
-  for (const [dependencyPackageName, expectedPackageDependencyValue] of Object.entries(
-    options.matchDependencyVersions
-  )) {
-    if (Array.isArray(expectedPackageDependencyValue)) {
-      ensurePackageMatchesSomeVersion(context, dependencyPackageName, expectedPackageDependencyValue);
-    } else {
-      ensurePackageIsCorrectVersion(context, dependencyPackageName, expectedPackageDependencyValue);
-    }
-  }
-}
-var ensurePackageIsCorrectVersion = (context, dependencyPackageName, expectedPackageDependencyValue) => {
-  const packageJson = context.getPackageJson();
-  const packageJsonPath = context.getPackageJsonPath();
-  const expectedPackageDependencyVersion = (0, import_semver.coerce)(expectedPackageDependencyValue);
-  if (expectedPackageDependencyVersion == null) {
-    throw new Error(
-      `Malformed expected package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${expectedPackageDependencyValue}'`
-    );
-  }
-  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
-  const actualPackageDependencyVersion = (0, import_semver.coerce)(actualPackageDependencyValue);
-  if (actualPackageDependencyVersion != null && actualPackageDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected dependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDependencyValue}' instead.`,
-      fixer: () => (0, import_utils3.mutateJson)(packageJsonPath, context.host, (input) => {
-        input.dependencies[dependencyPackageName] = expectedPackageDependencyValue;
-        return input;
-      })
-    });
-  }
-  const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = (0, import_semver.coerce)(actualPackageDevDependencyValue);
-  if (actualPackageDevDependencyVersion != null && actualPackageDevDependencyVersion.raw !== expectedPackageDependencyVersion.raw) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match version defined in monorepolint configuration '${expectedPackageDependencyValue}', got '${actualPackageDevDependencyValue}' instead`,
-      fixer: () => (0, import_utils3.mutateJson)(packageJsonPath, context.host, (input) => {
-        input.devDependencies[dependencyPackageName] = expectedPackageDependencyValue;
-        return input;
-      })
-    });
-  }
-};
-var ensurePackageMatchesSomeVersion = (context, dependencyPackageName, acceptedPackageDependencyValues) => {
-  const packageJson = context.getPackageJson();
-  const packageJsonPath = context.getPackageJsonPath();
-  const acceptedPackageDependencyVersions = acceptedPackageDependencyValues.map(
-    (acceptedPackageDependencyValue) => {
-      const acceptedPackageDependencyVersion = (0, import_semver.coerce)(acceptedPackageDependencyValue);
-      if (acceptedPackageDependencyVersion == null) {
-        throw new Error(
-          `Malformed accepted package dependency version defined in monorepolint configuration: ${dependencyPackageName} @ '${acceptedPackageDependencyValue}'`
-        );
-      }
-      return acceptedPackageDependencyVersion;
-    }
-  );
-  const actualPackageDependencyValue = packageJson.dependencies && packageJson.dependencies[dependencyPackageName];
-  const actualPackageDependencyVersion = (0, import_semver.coerce)(actualPackageDependencyValue);
-  if (actualPackageDependencyVersion != null && acceptedPackageDependencyVersions.every(
-    (acceptedPackageDependencyVersion) => actualPackageDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
-  )) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected dependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDependencyValue}' instead.`
-    });
-  }
-  const actualPackageDevDependencyValue = packageJson.devDependencies && packageJson.devDependencies[dependencyPackageName];
-  const actualPackageDevDependencyVersion = (0, import_semver.coerce)(actualPackageDevDependencyValue);
-  if (actualPackageDevDependencyVersion != null && acceptedPackageDependencyVersions.every(
-    (acceptedPackageDependencyVersion) => actualPackageDevDependencyVersion.raw !== acceptedPackageDependencyVersion.raw
-  )) {
-    context.addError({
-      file: packageJsonPath,
-      message: `Expected devDependency on ${dependencyPackageName} to match one of '${JSON.stringify(
-        acceptedPackageDependencyValues
-      )}', got '${actualPackageDevDependencyValue}' instead.`
-    });
-  }
-};
-var ConsistentVersions = createNewRuleConversion("ConsistentVersions", consistentVersions);
-
-// src/fileContents.ts
-var import_jest_diff3 = require("jest-diff");
-var path3 = __toESM(require("path"), 1);
-var r6 = __toESM(require("runtypes"), 1);
-var Options6 = r6.Union(
-  r6.Record({
-    file: r6.String,
-    generator: r6.Function,
-    template: r6.Undefined.optional(),
-    templateFile: r6.Undefined.optional()
-  }),
-  r6.Record({
-    file: r6.String,
-    generator: r6.Undefined.optional(),
-    template: r6.String,
-    templateFile: r6.Undefined.optional()
-  }),
-  r6.Record({
-    file: r6.String,
-    generator: r6.Undefined.optional(),
-    template: r6.Undefined.optional(),
-    templateFile: r6.String
-  })
-);
-var fileContents = {
-  check: function expectFileContents(context, opts) {
-    const fullPath = path3.join(context.packageDir, opts.file);
-    const expectedContent = getExpectedContents(context, opts);
-    const pathExists = context.host.exists(fullPath);
-    const actualContent = pathExists ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
-    if (actualContent !== expectedContent) {
-      context.addError({
-        file: fullPath,
-        message: "Expect file contents to match",
-        longMessage: (0, import_jest_diff3.diff)(expectedContent, actualContent, { expand: true }),
-        fixer: () => {
-          if (expectedContent === void 0) {
-            if (pathExists)
-              context.host.deleteFile(fullPath);
-          } else {
-            context.host.mkdir(path3.dirname(fullPath), { recursive: true });
-            context.host.writeFile(fullPath, expectedContent, { encoding: "utf-8" });
-          }
-        }
-      });
-    }
-  },
-  optionsRuntype: Options6
-};
-var optionsCache = /* @__PURE__ */ new Map();
-function getExpectedContents(context, opts) {
-  if (optionsCache.has(opts)) {
-    const cachedEntry = optionsCache.get(opts);
-    if (cachedEntry && typeof cachedEntry === "function") {
-      return cachedEntry(context);
-    }
-    return cachedEntry;
-  }
-  if (opts.generator) {
-    optionsCache.set(opts, opts.generator);
-    return opts.generator(context);
-  } else if (opts.templateFile) {
-    const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
-    const fullPath = path3.resolve(workspacePackageDir, opts.templateFile);
-    const template = context.host.readFile(fullPath, { encoding: "utf-8" });
-    optionsCache.set(opts, template);
-    return template;
-  } else {
-    optionsCache.set(opts, opts.template);
-    return opts.template;
-  }
-}
-var FileContents = createNewRuleConversion("FileContents", fileContents);
-
-// src/mustSatisfyPeerDependencies.ts
-var import_utils4 = require("@monorepolint/utils");
-var path4 = __toESM(require("path"), 1);
-var r7 = __toESM(require("runtypes"), 1);
-var import_semver2 = require("semver");
-var import_resolve_package_path2 = __toESM(require("resolve-package-path"), 1);
-var Options7 = r7.Union(
-  r7.Partial({
-    skipUnparseableRanges: r7.Undefined,
-    dependencyWhitelist: r7.Undefined,
-    dependencyBlacklist: r7.Undefined,
-    enforceForDevDependencies: r7.Undefined
-  }),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean
-  }).And(
-    r7.Partial({
-      dependencyWhitelist: r7.Undefined,
-      dependencyBlacklist: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyWhitelist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      dependencyBlacklist: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyBlacklist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      dependencyWhitelist: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      dependencyWhitelist: r7.Undefined,
-      dependencyBlacklist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyWhitelist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      dependencyBlacklist: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyBlacklist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      dependencyWhitelist: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      dependencyWhitelist: r7.Undefined,
-      dependencyBlacklist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyWhitelist: r7.Array(r7.String),
-    dependencyBlacklist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyWhitelist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      dependencyBlacklist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyBlacklist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined,
-      dependencyWhitelist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyWhitelist: r7.Array(r7.String),
-    dependencyBlacklist: r7.Array(r7.String)
-  }).And(
-    r7.Partial({
-      enforceForDevDependencies: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyWhitelist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      dependencyBlacklist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyBlacklist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      dependencyWhitelist: r7.Undefined
-    })
-  ),
-  r7.Record({
-    dependencyWhitelist: r7.Array(r7.String),
-    dependencyBlacklist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  }).And(
-    r7.Partial({
-      skipUnparseableRanges: r7.Undefined
-    })
-  ),
-  r7.Record({
-    skipUnparseableRanges: r7.Boolean,
-    dependencyWhitelist: r7.Array(r7.String),
-    dependencyBlacklist: r7.Array(r7.String),
-    enforceForDevDependencies: r7.Boolean
-  })
-);
-var mustSatisfyPeerDependencies = {
-  check: checkSatisfyPeerDependencies,
-  optionsRuntype: Options7
-};
-var MustSatisfyPeerDependencies = createNewRuleConversion(
-  "MustSatisfyPeerDependencies",
-  mustSatisfyPeerDependencies
-);
-var MATCH_ANY_VERSION_RANGE = /^(\*|x)$/;
-var MATCH_GREATER_OR_EQUAL_VERSION_RANGE = /^>= ?\d+(?:\.\d+|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?$/;
-var MATCH_MAJOR_VERSION_RANGE = /^(?:\^?\d+|\^?\d+\.x|\^?\d+\.x\.x|\^\d+\.\d+|\^\d+\.\d+\.x|\^\d+\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)$/;
-var RANGE_REGEX = /^(\*|x|>= ?\d+(?:\.\d+|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?|\^?\d+(\.x|\.x\.x|\.\d+|\.\d+\.x|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?( \|\| \^?\d+(\.x|\.x\.x|\.\d+|\.\d+\.x|\.\d+\.\d+(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?)?)*)$/;
-function checkSatisfyPeerDependencies(context, opts) {
-  const { dependencyBlacklist, dependencyWhitelist, enforceForDevDependencies, skipUnparseableRanges } = opts;
-  const packageJsonPath = path4.resolve(context.getPackageJsonPath());
-  const packageJson = context.host.readJson(packageJsonPath);
-  const packageDependencies = packageJson.dependencies || {};
-  const packageDevDependencies = packageJson.devDependencies || {};
-  const packagePeerDependencies = packageJson.peerDependencies || {};
-  const packageName = packageJson.name || packageJsonPath;
-  for (const [peerDependencyName, peerDependencyRange] of Object.entries(packagePeerDependencies)) {
-    if (shouldSkipPackage({ dependencyBlacklist, dependencyWhitelist, packageName: peerDependencyName })) {
-      continue;
-    }
-    const dependencyRange = packageDependencies[peerDependencyName];
-    if (dependencyRange != null) {
-      context.addError({
-        file: packageJsonPath,
-        message: `[0] Package ${packageName} has overloaded ${peerDependencyName} dependencies.
-	Peer dependency '${peerDependencyRange}' and regular dependency '${dependencyRange}'.`
-      });
-    }
-  }
-  const allRequiredPeerDependencies = {};
-  const allDependencies = enforceForDevDependencies ? [...Object.keys(packageDependencies), ...Object.keys(packageDevDependencies)] : Object.keys(packageDependencies);
-  for (const dependency of allDependencies) {
-    const dependencyPackageJsonPath = (0, import_resolve_package_path2.default)(dependency, path4.dirname(packageJsonPath));
-    if (dependencyPackageJsonPath == null) {
-      throw new Error(`Could not resolve ${dependency} from ${path4.dirname(packageJsonPath)}`);
-    }
-    const dependencyPackageJson = context.host.readJson(dependencyPackageJsonPath);
-    const requiredPeerDependencies = dependencyPackageJson.peerDependencies;
-    if (requiredPeerDependencies == null) {
-      continue;
-    }
-    for (const [peerDependencyName, range] of Object.entries(requiredPeerDependencies)) {
-      if (shouldSkipPackage({ dependencyBlacklist, dependencyWhitelist, packageName: peerDependencyName })) {
-        continue;
-      }
-      if (!isValidRange(range)) {
-        const message = `Unable to parse ${dependencyPackageJson.name}'s ${peerDependencyName} peer dependency range '${range}'.`;
-        if (skipUnparseableRanges) {
-          context.addWarning({ file: dependencyPackageJsonPath, message });
-          continue;
-        }
-        throw new Error(message);
-      }
-      if (allRequiredPeerDependencies[peerDependencyName] == null) {
-        allRequiredPeerDependencies[peerDependencyName] = [];
-      }
-      allRequiredPeerDependencies[peerDependencyName].push({ fromPackageName: dependencyPackageJson.name, range });
-    }
-  }
-  for (const [peerDependencyName, peerDependencyRequirements] of Object.entries(allRequiredPeerDependencies)) {
-    let mostStrictPeerRequirement = {
-      fromPeerDependencyRequirements: [peerDependencyRequirements[0]],
-      range: peerDependencyRequirements[0].range
-    };
-    for (const peerRequirement of peerDependencyRequirements) {
-      if (doesASatisfyB(mostStrictPeerRequirement.range, peerRequirement.range)) {
-        continue;
-      } else if (doesASatisfyB(peerRequirement.range, mostStrictPeerRequirement.range)) {
-        mostStrictPeerRequirement = {
-          fromPeerDependencyRequirements: [peerRequirement],
-          range: peerRequirement.range
-        };
-      } else {
-        const maybeIntersection = findIntersection(peerRequirement.range, mostStrictPeerRequirement.range);
-        if (maybeIntersection !== void 0) {
-          mostStrictPeerRequirement = {
-            fromPeerDependencyRequirements: [
-              ...mostStrictPeerRequirement.fromPeerDependencyRequirements,
-              peerRequirement
-            ],
-            range: maybeIntersection
-          };
-        } else {
-          context.addError({
-            file: packageJsonPath,
-            message: `[1] Package ${packageName} has conflicting inherited ${peerDependencyName} peer dependencies.
-	Dependency ${peerRequirement.fromPackageName} requires '${peerRequirement.range}' but
-	` + getMostStrictStatement(mostStrictPeerRequirement)
-          });
-        }
-      }
-    }
-    const packageDependencyRange = packageDependencies[peerDependencyName];
-    if (packageDependencyRange != null) {
-      if (!isValidRange(packageDependencyRange)) {
-        const message = `Unable to parse ${packageName}'s ${peerDependencyName} dependency range '${packageDependencyRange}'.`;
-        if (skipUnparseableRanges) {
-          context.addWarning({ file: packageJsonPath, message });
-        } else {
-          throw new Error(message);
-        }
-      } else if (!doesASatisfyB(packageDependencyRange, mostStrictPeerRequirement.range)) {
-        context.addError({
-          file: packageJsonPath,
-          message: `[2] Package ${packageName} dependency on ${peerDependencyName} '${packageDependencyRange}' does not satisfy inherited peer dependencies.
-	` + getMostStrictStatement(mostStrictPeerRequirement)
-        });
-      }
-    }
-    const packagePeerDependencyRange = packagePeerDependencies[peerDependencyName];
-    if (packageDependencyRange == null && packagePeerDependencyRange == null) {
-      context.addError({
-        file: packageJsonPath,
-        message: `[3] Package ${packageName} is missing required ${peerDependencyName} dependency.
-	` + getMostStrictStatement(mostStrictPeerRequirement),
-        fixer: getAddDependencyTypeFixer({
-          packageJsonPath,
-          dependencyType: "peerDependencies",
-          dependencyName: peerDependencyName,
-          version: mostStrictPeerRequirement.range,
-          host: context.host
-        })
-      });
-    }
-    if (packagePeerDependencyRange != null) {
-      if (!isValidRange(packagePeerDependencyRange)) {
-        const message = `Unable to parse ${packageName}'s ${peerDependencyName} peer dependency range '${packagePeerDependencyRange}'.`;
-        if (skipUnparseableRanges) {
-          context.addWarning({ file: packageJsonPath, message });
-        } else {
-          throw new Error(message);
-        }
-      } else if (!doesASatisfyB(packagePeerDependencyRange, mostStrictPeerRequirement.range)) {
-        context.addError({
-          file: packageJsonPath,
-          message: `[4] Package ${packageName} peer dependency on ${peerDependencyName} '${packagePeerDependencyRange}' is not strict enough.
-	` + getMostStrictStatement(mostStrictPeerRequirement),
-          fixer: getAddDependencyTypeFixer({
-            packageJsonPath,
-            dependencyType: "peerDependencies",
-            dependencyName: peerDependencyName,
-            version: mostStrictPeerRequirement.range,
-            host: context.host
-          })
-        });
-      }
-    }
-  }
-}
-function shouldSkipPackage({
-  dependencyBlacklist,
-  dependencyWhitelist,
-  packageName
-}) {
-  if (dependencyBlacklist != null && dependencyBlacklist.includes(packageName) || dependencyWhitelist != null && !dependencyWhitelist.includes(packageName)) {
-    return true;
-  }
-  return false;
-}
-function getMostStrictStatement(mostStrictPeerRequirement) {
-  if (mostStrictPeerRequirement.fromPeerDependencyRequirements.length === 1) {
-    const dependencyName = mostStrictPeerRequirement.fromPeerDependencyRequirements[0].fromPackageName;
-    return `Dependency ${dependencyName} requires '${mostStrictPeerRequirement.range}'.`;
-  } else {
-    const dependencyNames = mostStrictPeerRequirement.fromPeerDependencyRequirements.map((peerDependencyRequirement) => peerDependencyRequirement.fromPackageName).join(", ");
-    const dependencyRequirements = mostStrictPeerRequirement.fromPeerDependencyRequirements.map((peerDependencyRequirement) => `'${peerDependencyRequirement.range}'`).join(", ");
-    return `Dependencies [${dependencyNames}] require [${dependencyRequirements}] respectively, resolving to '${mostStrictPeerRequirement.range}'.`;
-  }
-}
-function findIntersection(a, b) {
-  if (doesASatisfyB(a, b)) {
-    return a;
-  } else if (doesASatisfyB(b, a)) {
-    return b;
-  }
-  if (isAnyVersionRange(a) || isAnyVersionRange(b)) {
-    throw new Error();
-  }
-  const aVersions = a.includes("||") ? a.split("||").map((s) => s.trim()) : [a];
-  const bVersions = b.includes("||") ? b.split("||").map((s) => s.trim()) : [b];
-  const aIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(a);
-  const bIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(b);
-  if (aIsGreaterOrEqualVersionRange && bIsGreaterOrEqualVersionRange) {
-    throw new Error();
-  }
-  if (aIsGreaterOrEqualVersionRange) {
-    const aSemVer = (0, import_semver2.coerce)(a);
-    const compatibleBVersions = bVersions.map((bVersion) => {
-      const bSemVer = (0, import_semver2.coerce)(bVersion);
-      if (bVersion.startsWith("^") && bSemVer.major >= aSemVer.major) {
-        return `^${bSemVer.compare(aSemVer) >= 0 ? bSemVer.raw : aSemVer.raw}`;
-      }
-      return bSemVer.compare(aSemVer) !== -1 ? bVersion : void 0;
-    }).filter((bVersion) => bVersion != null);
-    if (compatibleBVersions.length === 0) {
-      return void 0;
-    }
-    return compatibleBVersions.join(" || ");
-  }
-  if (bIsGreaterOrEqualVersionRange) {
-    const bSemVer = (0, import_semver2.coerce)(b);
-    const compatibleAVersions = aVersions.map((aVersion) => {
-      const aSemVer = (0, import_semver2.coerce)(aVersion);
-      if (aVersion.startsWith("^") && aSemVer.major >= bSemVer.major) {
-        return `^${aSemVer.compare(bSemVer) >= 0 ? aSemVer.raw : bSemVer.raw}`;
-      }
-      return aSemVer.compare(bSemVer) !== -1 ? aVersion : void 0;
-    }).filter((aVersion) => aVersion != null);
-    if (compatibleAVersions.length === 0) {
-      return void 0;
-    }
-    return compatibleAVersions.join(" || ");
-  }
-  const compatibleVersions = aVersions.map((aVersion) => {
-    const aSemVer = (0, import_semver2.coerce)(aVersion);
-    const majorMatchingBVersion = bVersions.find((m) => (0, import_semver2.coerce)(m).major === aSemVer.major);
-    if (majorMatchingBVersion === void 0) {
-      return void 0;
-    }
-    if (doesASatisfyB(aVersion, majorMatchingBVersion)) {
-      return aVersion;
-    } else if (doesASatisfyB(majorMatchingBVersion, aVersion)) {
-      return majorMatchingBVersion;
-    } else {
-      return void 0;
-    }
-  }).filter((aVersion) => aVersion !== void 0);
-  if (compatibleVersions.length === 0) {
-    return void 0;
-  }
-  return compatibleVersions.join(" || ");
-}
-function doesASatisfyB(a, b) {
-  if (a === b) {
-    return true;
-  }
-  const aIsAnyVersionRange = isAnyVersionRange(a);
-  const bIsAnyVersionRange = isAnyVersionRange(b);
-  if (bIsAnyVersionRange) {
-    return true;
-  } else if (aIsAnyVersionRange) {
-    return false;
-  }
-  const aVersions = a.includes("||") ? a.split("||").map((s) => s.trim()) : [a];
-  const bVersions = b.includes("||") ? b.split("||").map((s) => s.trim()) : [b];
-  const aIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(a);
-  const bIsGreaterOrEqualVersionRange = isGreaterOrEqualVersionRange(b);
-  if (aIsGreaterOrEqualVersionRange && bIsGreaterOrEqualVersionRange) {
-    const aSemVer = (0, import_semver2.coerce)(a);
-    const bSemVer = (0, import_semver2.coerce)(b);
-    return aSemVer.compare(bSemVer) !== -1;
-  } else if (bIsGreaterOrEqualVersionRange) {
-    const bSemVer = (0, import_semver2.coerce)(b);
-    return aVersions.every((aVersion) => {
-      const aSemVer = (0, import_semver2.coerce)(aVersion);
-      return aSemVer.compare(bSemVer) !== -1;
-    });
-  } else if (aIsGreaterOrEqualVersionRange) {
-    return false;
-  }
-  return aVersions.every((aVersion) => {
-    const aSemVer = (0, import_semver2.coerce)(aVersion);
-    const majorMatchingBVersion = bVersions.find((m) => (0, import_semver2.coerce)(m).major === aSemVer.major);
-    if (majorMatchingBVersion === void 0) {
-      return false;
-    }
-    const aVersionIsRange = isMajorVersionRange(aVersion);
-    const majorMatchingBSemVer = (0, import_semver2.coerce)(majorMatchingBVersion);
-    const majorMatchingBVersionIsRange = isMajorVersionRange(majorMatchingBVersion);
-    if (majorMatchingBVersionIsRange) {
-      return aSemVer.compare(majorMatchingBSemVer) !== -1;
-    } else {
-      if (aVersionIsRange) {
-        return false;
-      } else {
-        return aSemVer.compare(majorMatchingBSemVer) === 0;
-      }
-    }
-  });
-}
-function isAnyVersionRange(version) {
-  return MATCH_ANY_VERSION_RANGE.test(version);
-}
-function isGreaterOrEqualVersionRange(version) {
-  return MATCH_GREATER_OR_EQUAL_VERSION_RANGE.test(version);
-}
-function isMajorVersionRange(version) {
-  return MATCH_MAJOR_VERSION_RANGE.test(version);
-}
-function isValidRange(version) {
-  return RANGE_REGEX.test(version);
-}
-function getAddDependencyTypeFixer({
-  packageJsonPath,
-  dependencyType,
-  dependencyName,
-  version,
-  host
-}) {
-  return () => {
-    (0, import_utils4.mutateJson)(packageJsonPath, host, (packageJson) => {
-      if (packageJson[dependencyType] == null) {
-        packageJson[dependencyType] = {};
-      }
-      packageJson[dependencyType][dependencyName] = version;
-      return packageJson;
-    });
-  };
-}
-
-// src/packageOrder.ts
-var import_jest_diff4 = require("jest-diff");
-var r8 = __toESM(require("runtypes"), 1);
-var Options8 = r8.Record({
-  order: r8.Union(r8.Array(r8.String), r8.Function)
-}).Or(r8.Undefined);
-var defaultKeyOrder = [
-  "name",
-  "version",
-  "description",
-  "author",
-  "contributors",
-  "url",
-  "license",
-  "type",
-  "exports",
-  "private",
-  "engines",
-  "bin",
-  "types",
-  "main",
-  "module",
-  "typings",
-  "style",
-  "sideEffects",
-  "workspaces",
-  "husky",
-  "lint-staged",
-  "files",
-  "scripts",
-  "resolutions",
-  "dependencies",
-  "peerDependencies",
-  "devDependencies",
-  "optionalDependencies",
-  "publishConfig"
-];
-var packageOrder = {
-  check: function expectPackageOrder(context, opts) {
-    const packageJson = context.getPackageJson();
-    const packagePath = context.getPackageJsonPath();
-    const order = opts === void 0 ? defaultKeyOrder : opts.order;
-    const comparator = isOrderFunction(order) ? order(context) : createComparator(order);
-    const actualOrder = Object.keys(packageJson);
-    const expectedOrder = actualOrder.slice().sort(comparator);
-    if (!arrayOrderCompare2(actualOrder, expectedOrder)) {
-      context.addError({
-        file: packagePath,
-        message: "Incorrect order of fields in package.json",
-        longMessage: (0, import_jest_diff4.diff)(expectedOrder, actualOrder, { expand: true }),
-        fixer: () => {
-          const expectedPackageJson = {};
-          expectedOrder.forEach((key) => {
-            expectedPackageJson[key] = packageJson[key];
-          });
-          context.host.writeJson(packagePath, expectedPackageJson);
-        }
-      });
-    }
-  },
-  optionsRuntype: Options8
-};
-var PackageOrder = createNewRuleConversion("PackageOrder", packageOrder);
-function arrayOrderCompare2(a, b) {
-  for (let index = 0; index < a.length; index++) {
-    if (a[index] !== b[index]) {
-      return false;
-    }
-  }
-  return true;
-}
-function createComparator(order) {
-  return (a, b) => {
-    const aIndex = order.indexOf(a);
-    const bIndex = order.indexOf(b);
-    if (aIndex >= 0 && bIndex < 0) {
-      return -1;
-    } else if (aIndex < 0 && bIndex >= 0) {
-      return 1;
-    }
-    const compared = aIndex - bIndex;
-    if (compared !== 0) {
-      return compared;
-    } else {
-      return a.localeCompare(b);
-    }
-  };
-}
-function isOrderFunction(order) {
-  return !Array.isArray(order);
-}
-
-// src/packageEntry.ts
-var import_utils5 = require("@monorepolint/utils");
-var import_jest_diff5 = require("jest-diff");
-var r9 = __toESM(require("runtypes"), 1);
-var Options9 = r9.Union(
-  r9.Record({
-    entries: r9.Dictionary(r9.Unknown)
-  }).And(
-    r9.Partial({
-      entriesExist: r9.Undefined
-    })
-  ),
-  r9.Record({
-    entriesExist: r9.Array(r9.String)
-  }).And(
-    r9.Partial({
-      entries: r9.Undefined
-    })
-  ),
-  r9.Record({
-    entries: r9.Dictionary(r9.Unknown),
-    entriesExist: r9.Array(r9.String)
-  })
-);
-var packageEntry = {
-  check: function expectPackageEntry(context, options) {
-    const packageJson = context.getPackageJson();
-    if (options.entries) {
-      for (const key of Object.keys(options.entries)) {
-        const value = options.entries[key];
-        const entryDiff = (0, import_jest_diff5.diff)(JSON.stringify(value) + "\n", (JSON.stringify(packageJson[key]) || "") + "\n");
-        if (typeof value !== "object" && value !== packageJson[key] || entryDiff == null || !entryDiff.includes("Compared values have no visual difference")) {
-          context.addError({
-            file: context.getPackageJsonPath(),
-            message: createStandardizedEntryErrorMessage(key),
-            longMessage: entryDiff,
-            fixer: () => {
-              (0, import_utils5.mutateJson)(context.getPackageJsonPath(), context.host, (input) => {
-                input[key] = value;
-                return input;
-              });
-            }
-          });
-        }
-      }
-    }
-    if (options.entriesExist) {
-      for (const key of options.entriesExist) {
-        if (packageJson[key] === void 0) {
-          context.addError({
-            file: context.getPackageJsonPath(),
-            message: createExpectedEntryErrorMessage(key)
-          });
-        }
-      }
-    }
-  },
-  optionsRuntype: Options9
-};
-var PackageEntry = createNewRuleConversion("PackageEntry", packageEntry);
-function createStandardizedEntryErrorMessage(key) {
-  return `Expected standardized entry for '${key}'`;
-}
-function createExpectedEntryErrorMessage(key) {
-  return `Expected entry for '${key}' to exist`;
-}
-
-// src/packageScript.ts
-var import_utils6 = require("@monorepolint/utils");
-var import_jest_diff6 = require("jest-diff");
-var r10 = __toESM(require("runtypes"), 1);
-var Options10 = r10.Record({
-  scripts: r10.Dictionary(
-    r10.Union(
-      r10.String,
-      r10.Record({
-        options: r10.Array(r10.String.Or(r10.Undefined)),
-        fixValue: r10.Union(r10.String, r10.Undefined, r10.Literal(false)).optional()
-      })
-    )
-  )
-});
-var MSG_NO_SCRIPTS_BLOCK = "No scripts block in package.json";
-var packageScript = {
-  check: function expectPackageScript(context, options) {
-    const packageJson = context.getPackageJson();
-    if (packageJson.scripts === void 0) {
-      context.addError({
-        file: context.getPackageJsonPath(),
-        message: MSG_NO_SCRIPTS_BLOCK,
-        fixer: () => {
-          (0, import_utils6.mutateJson)(context.getPackageJsonPath(), context.host, (input) => {
-            input.scripts = {};
-            return input;
-          });
-        }
-      });
-      return;
-    }
-    for (const [name, value] of Object.entries(options.scripts)) {
-      const allowedValues = /* @__PURE__ */ new Set();
-      let fixValue;
-      let allowEmpty = false;
-      let fixToEmpty = false;
-      if (typeof value === "string") {
-        allowedValues.add(value);
-        fixValue = value;
-      } else {
-        for (const q of value.options) {
-          if (q === void 0) {
-            allowEmpty = true;
-          }
-          allowedValues.add(q);
-        }
-        fixToEmpty = Object.prototype.hasOwnProperty.call(value, "fixValue") && value.fixValue === void 0;
-        fixValue = value.fixValue;
-      }
-      const actualValue = packageJson.scripts[name];
-      if (!allowedValues.has(actualValue) && !(allowEmpty === true && actualValue === void 0)) {
-        let fixer;
-        if (fixValue !== false && (fixValue !== void 0 || fixToEmpty === true)) {
-          const q = fixValue;
-          fixer = () => {
-            (0, import_utils6.mutateJson)(context.getPackageJsonPath(), context.host, (input) => {
-              if (fixToEmpty && q === void 0) {
-                delete input.scripts[name];
-              } else {
-                input.scripts[name] = q;
-              }
-              return input;
-            });
-          };
-        }
-        const validOptionsString = Array.from(allowedValues.values()).map((a) => a === void 0 ? "(empty)" : `'${a}'`).join(", ");
-        context.addError({
-          file: context.getPackageJsonPath(),
-          message: `Expected standardized script entry for '${name}'. Valid options: ${validOptionsString}`,
-          longMessage: (0, import_jest_diff6.diff)(validOptionsString + "\n", (packageJson.scripts[name] || "") + "\n"),
-          fixer
-        });
-      }
-    }
-  },
-  optionsRuntype: Options10
-};
-var PackageScript = createNewRuleConversion("PackageScript", packageScript);
-
-// src/standardTsconfig.ts
-var import_utils7 = require("@monorepolint/utils");
-var import_jest_diff7 = require("jest-diff");
-var path5 = __toESM(require("path"), 1);
-var r11 = __toESM(require("runtypes"), 1);
-var DEFAULT_TSCONFIG_FILENAME = "tsconfig.json";
-var Options11 = r11.Partial({
-  file: r11.String,
-  generator: r11.Function,
-  tsconfigReferenceFile: r11.String,
-  template: r11.Record({}).Or(r11.String),
-  templateFile: r11.String,
-  excludedReferences: r11.Array(r11.String).Or(r11.Undefined),
-  additionalReferences: r11.Array(r11.String).Or(r11.Undefined)
-}).withConstraint(({ generator, template, templateFile }) => {
-  let count = 0;
-  if (generator) {
-    count++;
-  }
-  if (template) {
-    count++;
-  }
-  if (templateFile) {
-    count++;
-  }
-  return count === 1 || "Expect one of { generator, template, templateFile }";
-});
-var standardTsconfig = {
-  check: async function expectStandardTsconfig(context, opts) {
-    const tsconfigFileName = opts.file ?? DEFAULT_TSCONFIG_FILENAME;
-    const fullPath = path5.resolve(context.packageDir, tsconfigFileName);
-    const generator = getGenerator(context, opts);
-    const expectedContent = await generator(context);
-    const actualContent = context.host.exists(fullPath) ? context.host.readFile(fullPath, { encoding: "utf-8" }) : void 0;
-    if (expectedContent === void 0) {
-      context.addWarning({
-        file: fullPath,
-        message: "Excluding from expect-standard-tsconfig"
-      });
-      return;
-    }
-    if (actualContent !== expectedContent) {
-      context.addError({
-        file: fullPath,
-        message: "Expect file contents to match",
-        longMessage: (0, import_jest_diff7.diff)(expectedContent, actualContent, { expand: true }),
-        fixer: () => {
-          context.host.writeFile(fullPath, expectedContent, {
-            encoding: "utf-8"
-          });
-        }
-      });
-    }
-  },
-  optionsRuntype: Options11
-};
-var StandardTsConfig = createNewRuleConversion("StandardTsconfig", standardTsconfig);
-function getGenerator(context, opts) {
-  if (opts.generator) {
-    return opts.generator;
-  } else if (opts.templateFile) {
-    const { packageDir: workspacePackageDir } = context.getWorkspaceContext();
-    const fullPath = path5.resolve(workspacePackageDir, opts.templateFile);
-    const template = JSON.parse(context.host.readFile(fullPath, { encoding: "utf-8" }));
-    return makeGenerator(template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
-  } else if (opts.template) {
-    return makeGenerator(opts.template, opts.excludedReferences, opts.additionalReferences, opts.tsconfigReferenceFile);
-  } else {
-    throw new Error("Unable to make generator");
-  }
-}
-function makeGenerator(template, excludedReferences, additionalReferences, tsconfigReferenceFile) {
-  return async function generator(context) {
-    template = {
-      ...template,
-      references: []
-    };
-    const nameToDirectory = await context.getWorkspaceContext().getPackageNameToDir();
-    const packageJson = context.getPackageJson();
-    const deps = [...Object.keys(packageJson.dependencies || {}), ...Object.keys(packageJson.devDependencies || {})];
-    for (const dep of deps) {
-      const packageDir = nameToDirectory.get(dep);
-      if (packageDir !== void 0 && (excludedReferences === void 0 || (0, import_utils7.matchesAnyGlob)(dep, excludedReferences))) {
-        const absoluteReferencePath = tsconfigReferenceFile !== void 0 ? path5.join(packageDir, tsconfigReferenceFile) : packageDir;
-        template.references.push({
-          path: path5.relative(context.packageDir, absoluteReferencePath)
-        });
-      }
-    }
-    if (additionalReferences) {
-      for (const additionalReference of additionalReferences) {
-        template.references.push({
-          path: additionalReference
-        });
-      }
-    }
-    return JSON.stringify(template, void 0, 2) + "\n";
-  };
-}
-
-// src/nestedWorkspaces.ts
-var globby = __toESM(require("globby"), 1);
-var path6 = __toESM(require("path"), 1);
-var r12 = __toESM(require("runtypes"), 1);
-var Options12 = r12.Undefined;
-var nestedWorkspaces = {
-  check: (context) => {
-    const rootPackageJson = context.getWorkspaceContext().getPackageJson();
-    const packageJsonPaths = globby.globbySync(["*/**/package.json", "!**/node_modules/**"]);
-    const workspaces = Array.isArray(rootPackageJson.workspaces) ? rootPackageJson.workspaces : rootPackageJson.workspaces !== void 0 ? rootPackageJson.workspaces.packages : void 0;
-    if (workspaces === void 0 && packageJsonPaths.length > 0) {
-      context.addError({
-        file: context.getPackageJsonPath(),
-        message: 'The "workspace" field is missing, even though there are workspaces in the repository.'
-      });
-      return;
-    }
-    const workspacePackageJsons = (workspaces || []).map((item) => `${item}/package.json`);
-    const expandedWorkspacesGlobs = globby.globbySync([...workspacePackageJsons, "!**/node_modules/**"]);
-    const difference = packageJsonPaths.filter((packageJsonPath) => !expandedWorkspacesGlobs.includes(packageJsonPath));
-    if (difference.length !== 0) {
-      const differencesList = difference.map((packageJsonPath) => path6.dirname(packageJsonPath)).join(", ");
-      context.addError({
-        file: context.getPackageJsonPath(),
-        message: `The "workspace" field is missing one or more values: ${differencesList}. You may be able to use a glob to avoid listing each workspace individually, e.g. "packages/nested-workspace/*".`
-      });
-    }
-  },
-  optionsRuntype: Options12
-};
-var NestedWorkspaces = createNewRuleConversion("NestedWorkspaces", nestedWorkspaces);
-
-// src/requireDependency.ts
-var import_utils8 = require("@monorepolint/utils");
-var import_jest_diff8 = require("jest-diff");
-var r13 = __toESM(require("runtypes"), 1);
-var Options13 = r13.Partial({
-  dependencies: r13.Dictionary(r13.String),
-  devDependencies: r13.Dictionary(r13.String),
-  peerDependencies: r13.Dictionary(r13.String),
-  optionalDependencies: r13.Dictionary(r13.String)
-});
-var requireDependency = {
-  check: function expectPackageEntry2(context, options) {
-    const packageJson = context.getPackageJson();
-    const packageJsonPath = context.getPackageJsonPath();
-    [
-      "dependencies",
-      "devDependencies",
-      "peerDependencies",
-      "optionalDependencies"
-    ].forEach((type) => {
-      if (!options[type]) {
-        return;
-      }
-      if (packageJson[type] === void 0) {
-        context.addError({
-          file: packageJsonPath,
-          message: `No ${type} block, cannot add required ${type}.`,
-          fixer: () => {
-            (0, import_utils8.mutateJson)(packageJsonPath, context.host, (input) => {
-              input[type] = options[type];
-              return input;
-            });
-          }
-        });
-        return;
-      }
-      for (const [dep, version] of Object.entries(options[type])) {
-        if (packageJson[type][dep] !== version) {
-          context.addError({
-            file: packageJsonPath,
-            message: `Expected dependency ${dep}@${version}`,
-            longMessage: (0, import_jest_diff8.diff)(`${dep}@${version}
-`, `${dep}@${packageJson[type][dep] || "missing"}
-`),
-            fixer: () => {
-              (0, import_utils8.mutateJson)(packageJsonPath, context.host, (input) => {
-                input[type] = { ...input[type], [dep]: version };
-                return input;
-              });
-            }
-          });
-        }
-      }
-    });
-  },
-  optionsRuntype: Options13
-};
-var RequireDependency = createNewRuleConversion("RequireDependency", requireDependency);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AlphabeticalDependencies,
-  AlphabeticalScripts,
-  BannedDependencies,
-  ConsistentDependencies,
-  ConsistentVersions,
-  FileContents,
-  MustSatisfyPeerDependencies,
-  NestedWorkspaces,
-  PackageEntry,
-  PackageOrder,
-  PackageScript,
-  RequireDependency,
-  StandardTsConfig,
-  alphabeticalDependencies,
-  alphabeticalScripts,
-  bannedDependencies,
-  consistentDependencies,
-  consistentVersions,
-  fileContents,
-  mustSatisfyPeerDependencies,
-  nestedWorkspaces,
-  packageEntry,
-  packageOrder,
-  packageScript,
-  requireDependency,
-  standardTsconfig
-});
-/*!
- * Copyright 2019 Palantir Technologies, Inc.
- *
- * Licensed under the MIT license. See LICENSE file in the project root for details.
- *
- */
-/*!
- * Copyright 2020 Palantir Technologies, Inc.
- *
- * Licensed under the MIT license. See LICENSE file in the project root for details.
- *
- */
-/*!
- * Copyright 2022 Palantir Technologies, Inc.
- *
- * Licensed under the MIT license. See LICENSE file in the project root for details.
- *
- */
-/**
- * @license Copyright 2019 Palantir Technologies, Inc. All rights reserved.
- */
-//# sourceMappingURL=index.cjs.map