@amritk/lint 0.3.1 → 0.3.3

package/dist/core/validate-ruleset.js

@@ -1,121 +1,107 @@
-import { compileQuery } from './jsonpath.js';
-const SEVERITIES = new Set(['error', 'warn', 'info', 'hint', 'off']);
-const isObject = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+import { compileQuery } from "./jsonpath.js";
+const SEVERITIES = /* @__PURE__ */ new Set(["error", "warn", "info", "hint", "off"]);
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const isValidSeverity = (value) => {
-    if (typeof value === 'number')
-        return Number.isInteger(value) && value >= 0 && value <= 3;
-    return typeof value === 'string' && SEVERITIES.has(value);
+  if (typeof value === "number")
+    return Number.isInteger(value) && value >= 0 && value <= 3;
+  return typeof value === "string" && SEVERITIES.has(value);
 };
 const validateThen = (then, path, problems) => {
-    const entries = Array.isArray(then) ? then : [then];
-    entries.forEach((entry, index) => {
-        const at = Array.isArray(then) ? [...path, index] : path;
-        if (!isObject(entry)) {
-            problems.push({ message: '`then` must be an object (or array of objects)', path: at });
-            return;
-        }
-        const fn = entry['function'];
-        if (typeof fn !== 'string' && typeof fn !== 'function') {
-            problems.push({ message: '`then.function` must be a function name or reference', path: [...at, 'function'] });
-        }
-        if (entry['field'] !== undefined && typeof entry['field'] !== 'string') {
-            problems.push({ message: '`then.field` must be a string', path: [...at, 'field'] });
-        }
-    });
-};
-const validateRule = (name, entry, path, problems) => {
-    // Shorthand: boolean toggle or a severity string.
-    if (typeof entry === 'boolean')
-        return;
-    if (typeof entry === 'string') {
-        if (!isValidSeverity(entry)) {
-            problems.push({ message: `Rule "${name}" has invalid severity "${entry}"`, path });
-        }
-        return;
-    }
+  const entries = Array.isArray(then) ? then : [then];
+  entries.forEach((entry, index) => {
+    const at = Array.isArray(then) ? [...path, index] : path;
     if (!isObject(entry)) {
-        problems.push({ message: `Rule "${name}" must be an object, boolean, or severity string`, path });
-        return;
+      problems.push({ message: "`then` must be an object (or array of objects)", path: at });
+      return;
     }
-    if (entry['given'] === undefined) {
-        problems.push({ message: `Rule "${name}" is missing \`given\``, path: [...path, 'given'] });
+    const fn = entry["function"];
+    if (typeof fn !== "string" && typeof fn !== "function") {
+      problems.push({ message: "`then.function` must be a function name or reference", path: [...at, "function"] });
     }
-    else if (typeof entry['given'] !== 'string' && !Array.isArray(entry['given'])) {
-        problems.push({ message: `Rule "${name}" \`given\` must be a string or array`, path: [...path, 'given'] });
-    }
-    else {
-        // Flag a malformed JSONPath expression so it does not silently match nothing
-        // at run time. Alias references (`#Alias`) are only valid once expanded, so
-        // they are skipped here.
-        const givens = Array.isArray(entry['given']) ? entry['given'] : [entry['given']];
-        givens.forEach((given, index) => {
-            if (typeof given !== 'string' || given.startsWith('#'))
-                return;
-            const error = compileQuery(given).error;
-            if (error !== undefined) {
-                const at = Array.isArray(entry['given']) ? [...path, 'given', index] : [...path, 'given'];
-                problems.push({ message: `Rule "${name}" has an invalid \`given\` "${given}": ${error}`, path: at });
-            }
-        });
-    }
-    if (entry['then'] === undefined) {
-        problems.push({ message: `Rule "${name}" is missing \`then\``, path: [...path, 'then'] });
-    }
-    else {
-        validateThen(entry['then'], [...path, 'then'], problems);
-    }
-    if (entry['severity'] !== undefined && !isValidSeverity(entry['severity'])) {
-        problems.push({ message: `Rule "${name}" has invalid severity`, path: [...path, 'severity'] });
-    }
-    if (entry['formats'] !== undefined && !Array.isArray(entry['formats'])) {
-        problems.push({ message: `Rule "${name}" \`formats\` must be an array`, path: [...path, 'formats'] });
+    if (entry["field"] !== void 0 && typeof entry["field"] !== "string") {
+      problems.push({ message: "`then.field` must be a string", path: [...at, "field"] });
     }
+  });
 };
-/**
- * Validates the *shape* of a ruleset definition, returning a list of problems
- * (empty when valid). This is a lightweight structural check — it does not load
- * `extends` targets or verify that referenced functions exist — so a malformed
- * ruleset surfaces actionable diagnostics instead of failing obscurely at runtime.
- */
-export const validateRuleset = (definition) => {
-    const problems = [];
-    if (!isObject(definition)) {
-        return [{ message: 'Ruleset must be an object', path: [] }];
-    }
-    if (definition['rules'] !== undefined) {
-        if (!isObject(definition['rules'])) {
-            problems.push({ message: '`rules` must be an object', path: ['rules'] });
-        }
-        else {
-            for (const [name, entry] of Object.entries(definition['rules'])) {
-                validateRule(name, entry, ['rules', name], problems);
-            }
-        }
-    }
-    const ext = definition['extends'];
-    if (ext !== undefined && typeof ext !== 'string' && !Array.isArray(ext) && !isObject(ext)) {
-        problems.push({ message: '`extends` must be a string, array, or object', path: ['extends'] });
-    }
-    if (definition['overrides'] !== undefined && !Array.isArray(definition['overrides'])) {
-        problems.push({ message: '`overrides` must be an array', path: ['overrides'] });
-    }
-    else if (Array.isArray(definition['overrides'])) {
-        definition['overrides'].forEach((override, index) => {
-            if (!isObject(override) || !Array.isArray(override['files'])) {
-                problems.push({ message: 'Each override must have a `files` array', path: ['overrides', index] });
-            }
-        });
-    }
-    if (definition['functions'] !== undefined && !Array.isArray(definition['functions'])) {
-        problems.push({ message: '`functions` must be an array of names', path: ['functions'] });
-    }
-    if (definition['formats'] !== undefined && !Array.isArray(definition['formats'])) {
-        problems.push({ message: '`formats` must be an array', path: ['formats'] });
-    }
-    // A ruleset with neither rules nor extends does nothing — flag it.
-    if (definition.rules === undefined &&
-        definition.extends === undefined) {
-        problems.push({ message: 'Ruleset has no `rules` and no `extends` (it will produce no findings)', path: [] });
-    }
-    return problems;
+const validateRule = (name, entry, path, problems) => {
+  if (typeof entry === "boolean")
+    return;
+  if (typeof entry === "string") {
+    if (!isValidSeverity(entry)) {
+      problems.push({ message: `Rule "${name}" has invalid severity "${entry}"`, path });
+    }
+    return;
+  }
+  if (!isObject(entry)) {
+    problems.push({ message: `Rule "${name}" must be an object, boolean, or severity string`, path });
+    return;
+  }
+  if (entry["given"] === void 0) {
+    problems.push({ message: `Rule "${name}" is missing \`given\``, path: [...path, "given"] });
+  } else if (typeof entry["given"] !== "string" && !Array.isArray(entry["given"])) {
+    problems.push({ message: `Rule "${name}" \`given\` must be a string or array`, path: [...path, "given"] });
+  } else {
+    const givens = Array.isArray(entry["given"]) ? entry["given"] : [entry["given"]];
+    givens.forEach((given, index) => {
+      if (typeof given !== "string" || given.startsWith("#"))
+        return;
+      const error = compileQuery(given).error;
+      if (error !== void 0) {
+        const at = Array.isArray(entry["given"]) ? [...path, "given", index] : [...path, "given"];
+        problems.push({ message: `Rule "${name}" has an invalid \`given\` "${given}": ${error}`, path: at });
+      }
+    });
+  }
+  if (entry["then"] === void 0) {
+    problems.push({ message: `Rule "${name}" is missing \`then\``, path: [...path, "then"] });
+  } else {
+    validateThen(entry["then"], [...path, "then"], problems);
+  }
+  if (entry["severity"] !== void 0 && !isValidSeverity(entry["severity"])) {
+    problems.push({ message: `Rule "${name}" has invalid severity`, path: [...path, "severity"] });
+  }
+  if (entry["formats"] !== void 0 && !Array.isArray(entry["formats"])) {
+    problems.push({ message: `Rule "${name}" \`formats\` must be an array`, path: [...path, "formats"] });
+  }
+};
+const validateRuleset = (definition) => {
+  const problems = [];
+  if (!isObject(definition)) {
+    return [{ message: "Ruleset must be an object", path: [] }];
+  }
+  if (definition["rules"] !== void 0) {
+    if (!isObject(definition["rules"])) {
+      problems.push({ message: "`rules` must be an object", path: ["rules"] });
+    } else {
+      for (const [name, entry] of Object.entries(definition["rules"])) {
+        validateRule(name, entry, ["rules", name], problems);
+      }
+    }
+  }
+  const ext = definition["extends"];
+  if (ext !== void 0 && typeof ext !== "string" && !Array.isArray(ext) && !isObject(ext)) {
+    problems.push({ message: "`extends` must be a string, array, or object", path: ["extends"] });
+  }
+  if (definition["overrides"] !== void 0 && !Array.isArray(definition["overrides"])) {
+    problems.push({ message: "`overrides` must be an array", path: ["overrides"] });
+  } else if (Array.isArray(definition["overrides"])) {
+    definition["overrides"].forEach((override, index) => {
+      if (!isObject(override) || !Array.isArray(override["files"])) {
+        problems.push({ message: "Each override must have a `files` array", path: ["overrides", index] });
+      }
+    });
+  }
+  if (definition["functions"] !== void 0 && !Array.isArray(definition["functions"])) {
+    problems.push({ message: "`functions` must be an array of names", path: ["functions"] });
+  }
+  if (definition["formats"] !== void 0 && !Array.isArray(definition["formats"])) {
+    problems.push({ message: "`formats` must be an array", path: ["formats"] });
+  }
+  if (definition.rules === void 0 && definition.extends === void 0) {
+    problems.push({ message: "Ruleset has no `rules` and no `extends` (it will produce no findings)", path: [] });
+  }
+  return problems;
+};
+export {
+  validateRuleset
 };

package/dist/fix/apply.js

@@ -1,101 +1,63 @@
-import { applyEditOpsWithChanges } from '../parsers/index.js';
-/** The ops that structurally reshape an array, invalidating positional indices into it. */
-const STRUCTURAL_ARRAY_OPS = new Set(['removeItems', 'reorderArray', 'insertItem']);
+import { applyEditOpsWithChanges } from "../parsers/index.js";
+const STRUCTURAL_ARRAY_OPS = /* @__PURE__ */ new Set(["removeItems", "reorderArray", "insertItem"]);
 const isStructuralArrayOp = (op) => STRUCTURAL_ARRAY_OPS.has(op.op);
-/**
- * Whether `path` addresses (or reaches into) an array that an earlier op in this
- * batch already reshaped. After a `removeItems`/`reorderArray`/`insertItem`, the
- * element indices of that array are stale, so a second op that either targets the
- * same array or indexes into it by position would act on the wrong element. Such
- * an op is deferred to the next fixpoint pass, which re-derives indices from the
- * freshly-parsed document.
- */
 const touchesModifiedArray = (path, modified) => modified.some((array) => {
-    if (array.length > path.length)
-        return false;
-    if (!array.every((segment, i) => segment === path[i]))
-        return false;
-    // Another structural op on the same array conflicts; a deeper op conflicts
-    // only when it indexes the array by position (the stale part).
-    return array.length === path.length || typeof path[array.length] === 'number';
+  if (array.length > path.length)
+    return false;
+  if (!array.every((segment, i) => segment === path[i]))
+    return false;
+  return array.length === path.length || typeof path[array.length] === "number";
 });
-/**
- * Computes the structural edits for every fixable finding in `diagnostics`, then
- * applies them to `input` in one pass. Edits from different findings that come
- * out identical (e.g. several "not alphabetical" findings on one array all asking
- * for the same reorder) are de-duplicated so the edit is applied once.
- *
- * `data` is the *unresolved* parsed document: fixers read the real node at a
- * finding's path to derive the edit, and edits whose path no longer resolves are
- * dropped — so a finding on an inlined `$ref` node simply isn't fixed rather than
- * corrupting the source.
- *
- * When two ops in one batch would both reshape the same array, only the first is
- * applied this pass; the second is *deferred* and its finding is left unreported,
- * so the surrounding fixpoint loop re-derives it against the already-edited
- * document (where the indices are fresh) on the next pass. A finding is reported
- * in `applied` only when *every* edit it contributed actually changed the text —
- * a partially-applied or deferred fix is retried rather than falsely counted.
- */
-export const applyFixes = (input, format, data, diagnostics, fixers, options = {}) => {
-    const safeOnly = options.safeOnly !== false;
-    // Gather each candidate finding's ops up front so we can reason about conflicts
-    // across the whole batch before lowering anything to text.
-    const candidates = [];
-    for (const diagnostic of diagnostics) {
-        const fixer = fixers[String(diagnostic.code)];
-        if (!fixer)
-            continue;
-        if (safeOnly && fixer.safe === false)
-            continue;
-        const produced = fixer.fix({ diagnostic, data, format });
-        if (!produced)
-            continue;
-        const ops = Array.isArray(produced) ? produced : [produced];
-        if (ops.length === 0)
-            continue;
-        candidates.push({ fix: { code: diagnostic.code, path: diagnostic.path }, ops });
+const applyFixes = (input, format, data, diagnostics, fixers, options = {}) => {
+  const safeOnly = options.safeOnly !== false;
+  const candidates = [];
+  for (const diagnostic of diagnostics) {
+    const fixer = fixers[String(diagnostic.code)];
+    if (!fixer)
+      continue;
+    if (safeOnly && fixer.safe === false)
+      continue;
+    const produced = fixer.fix({ diagnostic, data, format });
+    if (!produced)
+      continue;
+    const ops2 = Array.isArray(produced) ? produced : [produced];
+    if (ops2.length === 0)
+      continue;
+    candidates.push({ fix: { code: diagnostic.code, path: diagnostic.path }, ops: ops2 });
+  }
+  const ops = [];
+  const indexByKey = /* @__PURE__ */ new Map();
+  const modifiedArrays = [];
+  const planned = [];
+  for (const candidate of candidates) {
+    const indices = [];
+    let deferred = false;
+    for (const op of candidate.ops) {
+      const key = JSON.stringify(op);
+      const existing = indexByKey.get(key);
+      if (existing !== void 0) {
+        indices.push(existing);
+        continue;
+      }
+      if (touchesModifiedArray(op.path, modifiedArrays)) {
+        deferred = true;
+        continue;
+      }
+      const index = ops.length;
+      indexByKey.set(key, index);
+      ops.push(op);
+      if (isStructuralArrayOp(op))
+        modifiedArrays.push(op.path);
+      indices.push(index);
     }
-    const ops = [];
-    const indexByKey = new Map();
-    const modifiedArrays = [];
-    // Per candidate: the batch index of each op that made it into this pass, and
-    // whether any op had to be deferred (which keeps the finding unreported so it
-    // is retried once the earlier structural edit has landed).
-    const planned = [];
-    for (const candidate of candidates) {
-        const indices = [];
-        let deferred = false;
-        for (const op of candidate.ops) {
-            const key = JSON.stringify(op);
-            // De-duplicate identical edits (e.g. several findings on one array all asking
-            // for the same reorder): the same edit is applied — and counted — once, and
-            // is never a conflict with itself.
-            const existing = indexByKey.get(key);
-            if (existing !== undefined) {
-                indices.push(existing);
-                continue;
-            }
-            // A distinct op that would reshape or index into an already-reshaped array
-            // is deferred to the next pass, where indices are re-derived from fresh data.
-            if (touchesModifiedArray(op.path, modifiedArrays)) {
-                deferred = true;
-                continue;
-            }
-            const index = ops.length;
-            indexByKey.set(key, index);
-            ops.push(op);
-            if (isStructuralArrayOp(op))
-                modifiedArrays.push(op.path);
-            indices.push(index);
-        }
-        planned.push({ fix: candidate.fix, indices, deferred });
-    }
-    if (ops.length === 0)
-        return { output: input, applied: [], changed: false };
-    const { output, changed } = applyEditOpsWithChanges(input, format, ops);
-    const applied = planned
-        .filter((plan) => !plan.deferred && plan.indices.length > 0 && plan.indices.every((index) => changed[index]))
-        .map((plan) => plan.fix);
-    return { output, applied, changed: output !== input };
+    planned.push({ fix: candidate.fix, indices, deferred });
+  }
+  if (ops.length === 0)
+    return { output: input, applied: [], changed: false };
+  const { output, changed } = applyEditOpsWithChanges(input, format, ops);
+  const applied = planned.filter((plan) => !plan.deferred && plan.indices.length > 0 && plan.indices.every((index) => changed[index])).map((plan) => plan.fix);
+  return { output, applied, changed: output !== input };
+};
+export {
+  applyFixes
 };

package/dist/fix/index.js

@@ -1,2 +1,7 @@
-export { applyFixes } from './apply.js';
-export { createFixPlugin, FIX_PLUGIN_NAME } from './plugin.js';
+import { applyFixes } from "./apply.js";
+import { createFixPlugin, FIX_PLUGIN_NAME } from "./plugin.js";
+export {
+  FIX_PLUGIN_NAME,
+  applyFixes,
+  createFixPlugin
+};

package/dist/fix/plugin.js

@@ -1,21 +1,16 @@
-import { applyFixes } from './apply.js';
-/** The name the fix plugin registers under (its `data` is surfaced here). */
-export const FIX_PLUGIN_NAME = 'fix';
-/**
- * Builds the auto-fix {@link LintPlugin} from a {@link FixerRegistry}. As a
- * post-lint plugin it reads the run's findings and the raw document text, applies
- * the fixers' edits, and returns the rewritten text as `output` plus the list of
- * repaired findings as `data`. The core engine stays unaware of fixing — remove
- * this plugin (and the `../fix` dependency) and Linter lints exactly as
- * before.
- */
-export const createFixPlugin = (fixers, options = {}) => ({
-    name: FIX_PLUGIN_NAME,
-    afterLint: (diagnostics, context) => {
-        const result = applyFixes(context.input, context.format, context.document.data, diagnostics, fixers, options);
-        if (!result.changed)
-            return undefined;
-        const data = { applied: result.applied };
-        return { output: result.output, data };
-    },
+import { applyFixes } from "./apply.js";
+const FIX_PLUGIN_NAME = "fix";
+const createFixPlugin = (fixers, options = {}) => ({
+  name: FIX_PLUGIN_NAME,
+  afterLint: (diagnostics, context) => {
+    const result = applyFixes(context.input, context.format, context.document.data, diagnostics, fixers, options);
+    if (!result.changed)
+      return void 0;
+    const data = { applied: result.applied };
+    return { output: result.output, data };
+  }
 });
+export {
+  FIX_PLUGIN_NAME,
+  createFixPlugin
+};

package/dist/functions/alphabetical.js

@@ -1,55 +1,44 @@
-const isRecord = (value) => typeof value === 'object' && value !== null;
-const isStringOrNumber = (value) => typeof value === 'string' || typeof value === 'number';
-/** A string made up only of digits, e.g. an integer-like object key such as "10". */
-const isIntegerLike = (value) => typeof value === 'string' && /^(?:0|[1-9]\d*)$/.test(value);
+const isRecord = (value) => typeof value === "object" && value !== null;
+const isStringOrNumber = (value) => typeof value === "string" || typeof value === "number";
+const isIntegerLike = (value) => typeof value === "string" && /^(?:0|[1-9]\d*)$/.test(value);
 const compare = (a, b) => {
-    // Deliberate deviation from Spectral, which relies on source order and falls
-    // back to `localeCompare`: JavaScript enumerates integer-like object keys in
-    // ascending numeric order ({ "2": …, "10": … }), yet `localeCompare` sorts
-    // "10" before "2" and would flag that natural key order as a violation.
-    // Comparing integer-like strings numerically avoids that false positive.
-    if (isIntegerLike(a) && isIntegerLike(b))
-        return Math.sign(Number(a) - Number(b));
-    // Match Spectral: when either side is a real number or a numeric string,
-    // compare numerically so mixed inputs like [2, "10"] read as ordered.
-    if ((typeof a === 'number' || !Number.isNaN(Number(a))) && (typeof b === 'number' || !Number.isNaN(Number(b)))) {
-        return Math.min(1, Math.max(-1, Number(a) - Number(b)));
-    }
-    if (typeof a !== 'string' || typeof b !== 'string')
-        return 0;
-    return a.localeCompare(b);
+  if (isIntegerLike(a) && isIntegerLike(b))
+    return Math.sign(Number(a) - Number(b));
+  if ((typeof a === "number" || !Number.isNaN(Number(a))) && (typeof b === "number" || !Number.isNaN(Number(b)))) {
+    return Math.min(1, Math.max(-1, Number(a) - Number(b)));
+  }
+  if (typeof a !== "string" || typeof b !== "string")
+    return 0;
+  return a.localeCompare(b);
 };
-/** Flags array items or object keys that are not in ascending (optionally `keyedBy`) order. */
-export const alphabetical = (input, options, context) => {
-    if (typeof input !== 'object' || input === null)
-        return [];
-    const isArray = Array.isArray(input);
-    const rawItems = isArray ? input : Object.keys(input);
-    const keyedBy = options?.keyedBy;
-    // Resolve the actual comparands. With `keyedBy` we read a property off each
-    // item, which is only meaningful when every item is an object; otherwise the
-    // comparison would silently run against `undefined`. Surface the same explicit
-    // findings Spectral does instead of producing a misleading order violation.
-    const items = [];
-    for (const item of rawItems) {
-        if (keyedBy) {
-            if (!isRecord(item))
-                return [{ message: 'The value must be an object' }];
-            items.push(item[keyedBy]);
-        }
-        else {
-            items.push(item);
-        }
-    }
-    if (!items.every(isStringOrNumber)) {
-        return [{ message: 'The value must be one of the allowed types: number, string' }];
+const alphabetical = (input, options, context) => {
+  if (typeof input !== "object" || input === null)
+    return [];
+  const isArray = Array.isArray(input);
+  const rawItems = isArray ? input : Object.keys(input);
+  const keyedBy = options?.keyedBy;
+  const items = [];
+  for (const item of rawItems) {
+    if (keyedBy) {
+      if (!isRecord(item))
+        return [{ message: "The value must be an object" }];
+      items.push(item[keyedBy]);
+    } else {
+      items.push(item);
     }
-    const results = [];
-    for (let i = 0; i < items.length - 1; i++) {
-        if (compare(items[i], items[i + 1]) > 0) {
-            const path = isArray ? [...context.path, i + 1] : [...context.path, rawItems[i + 1]];
-            results.push({ message: 'The items must be in alphabetical order', path });
-        }
+  }
+  if (!items.every(isStringOrNumber)) {
+    return [{ message: "The value must be one of the allowed types: number, string" }];
+  }
+  const results = [];
+  for (let i = 0; i < items.length - 1; i++) {
+    if (compare(items[i], items[i + 1]) > 0) {
+      const path = isArray ? [...context.path, i + 1] : [...context.path, rawItems[i + 1]];
+      results.push({ message: "The items must be in alphabetical order", path });
     }
-    return results;
+  }
+  return results;
+};
+export {
+  alphabetical
 };

package/dist/functions/casing.js

@@ -1,52 +1,46 @@
 const PATTERNS = {
-    flat: '[a-z][a-z{d}]*',
-    camel: '[a-z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*',
-    pascal: '[A-Z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*',
-    // Segments after a separator may start with a digit, matching Spectral (so
-    // "foo-2fa" is valid kebab case). The sub-pattern is `[a-z{d}]+`, not the
-    // stricter `[a-z][a-z{d}]*` which would require a letter right after the sep.
-    kebab: '[a-z][a-z{d}]*(?:-[a-z{d}]+)*',
-    cobol: '[A-Z][A-Z{d}]*(?:-[A-Z{d}]+)*',
-    snake: '[a-z][a-z{d}]*(?:_[a-z{d}]+)*',
-    macro: '[A-Z][A-Z{d}]*(?:_[A-Z{d}]+)*',
+  flat: "[a-z][a-z{d}]*",
+  camel: "[a-z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*",
+  pascal: "[A-Z][a-z{d}]*(?:[A-Z{d}](?:[a-z{d}]+|$))*",
+  // Segments after a separator may start with a digit, matching Spectral (so
+  // "foo-2fa" is valid kebab case). The sub-pattern is `[a-z{d}]+`, not the
+  // stricter `[a-z][a-z{d}]*` which would require a letter right after the sep.
+  kebab: "[a-z][a-z{d}]*(?:-[a-z{d}]+)*",
+  cobol: "[A-Z][A-Z{d}]*(?:-[A-Z{d}]+)*",
+  snake: "[a-z][a-z{d}]*(?:_[a-z{d}]+)*",
+  macro: "[A-Z][A-Z{d}]*(?:_[A-Z{d}]+)*"
 };
 const VALID_TYPES = Object.keys(PATTERNS);
-const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 const buildRegExp = (options) => {
-    const digits = options.disallowDigits ? '' : '0-9';
-    const base = PATTERNS[options.type].replace(/\{d\}/g, digits);
-    if (!options.separator)
-        return new RegExp(`^${base}$`);
-    const sep = escapeRegExp(options.separator.char);
-    const leading = options.separator.allowLeading ? `${sep}?` : '';
-    return new RegExp(`^${leading}${base}(?:${sep}${base})*$`);
+  const digits = options.disallowDigits ? "" : "0-9";
+  const base = PATTERNS[options.type].replace(/\{d\}/g, digits);
+  if (!options.separator)
+    return new RegExp(`^${base}$`);
+  const sep = escapeRegExp(options.separator.char);
+  const leading = options.separator.allowLeading ? `${sep}?` : "";
+  return new RegExp(`^${leading}${base}(?:${sep}${base})*$`);
 };
-/** Flags a string that does not match the configured casing style. */
-export const casing = (input, options) => {
-    if (!options?.type)
-        return [];
-    // Guard an unknown `type` before it reaches `PATTERNS[type]`, which would be
-    // `undefined` and crash on `.replace`. Mirror Spectral's option schema by
-    // naming every accepted value in a single, clear error finding.
-    if (!VALID_TYPES.includes(options.type)) {
-        return [
-            {
-                message: `"casing" function and its "type" option accept the following values: ${VALID_TYPES.join(', ')}`,
-            },
-        ];
-    }
-    if (typeof input !== 'string' || input.length === 0)
-        return [];
-    // Spectral special-cases a lone separator char with `allowLeading` as valid.
-    // This is what keeps the OpenAPI root path "/" from being flagged.
-    if (input.length === 1 &&
-        options.separator !== undefined &&
-        options.separator.allowLeading === true &&
-        input === options.separator.char) {
-        return [];
-    }
-    if (!buildRegExp(options).test(input)) {
-        return [{ message: `The value must be in ${options.type} case` }];
-    }
+const casing = (input, options) => {
+  if (!options?.type)
     return [];
+  if (!VALID_TYPES.includes(options.type)) {
+    return [
+      {
+        message: `"casing" function and its "type" option accept the following values: ${VALID_TYPES.join(", ")}`
+      }
+    ];
+  }
+  if (typeof input !== "string" || input.length === 0)
+    return [];
+  if (input.length === 1 && options.separator !== void 0 && options.separator.allowLeading === true && input === options.separator.char) {
+    return [];
+  }
+  if (!buildRegExp(options).test(input)) {
+    return [{ message: `The value must be in ${options.type} case` }];
+  }
+  return [];
+};
+export {
+  casing
 };