vigiles 14.6.7 → 14.8.0

package/dist/leaderboard.js

@@ -12,18 +12,30 @@
  * model and stack on top later; this part runs anywhere in CI for free.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.W_TRIFECTA = exports.W_NO_CONTRACT = exports.W_OVERLAP = exports.W_DANGLING_REF = exports.W_NO_DESCRIPTION = exports.W_MISSING_HOOK = void 0;
-exports.gradeFor = gradeFor;
-exports.reportDeductions = reportDeductions;
-exports.isEmptyMachine = isEmptyMachine;
-exports.computeIntegrityScore = computeIntegrityScore;
-exports.scoreReport = scoreReport;
+exports.scoreReport = exports.computeIntegrityScore = exports.isEmptyMachine = exports.reportDeductions = exports.gradeFor = exports.W_TRIFECTA = exports.W_NO_CONTRACT = exports.W_OVERLAP = exports.W_DANGLING_REF = exports.W_NO_DESCRIPTION = exports.W_MISSING_HOOK = void 0;
 exports.rankPlugins = rankPlugins;
 exports.formatLeaderboard = formatLeaderboard;
 exports.formatLeaderboardMarkdown = formatLeaderboardMarkdown;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const scan_js_1 = require("./scan.js");
+// The pure, node-free scoring core lives in ./score-core.js (extracted so the
+// in-browser audit's report builder can import scoring WITHOUT this module's
+// node-only scanPlugin/pluginLabel → scan.ts → @ast-grep/napi chain). Re-exported
+// here so every existing `from "./leaderboard.js"` consumer keeps working.
+const score_core_js_1 = require("./score-core.js");
+var score_core_js_2 = require("./score-core.js");
+Object.defineProperty(exports, "W_MISSING_HOOK", { enumerable: true, get: function () { return score_core_js_2.W_MISSING_HOOK; } });
+Object.defineProperty(exports, "W_NO_DESCRIPTION", { enumerable: true, get: function () { return score_core_js_2.W_NO_DESCRIPTION; } });
+Object.defineProperty(exports, "W_DANGLING_REF", { enumerable: true, get: function () { return score_core_js_2.W_DANGLING_REF; } });
+Object.defineProperty(exports, "W_OVERLAP", { enumerable: true, get: function () { return score_core_js_2.W_OVERLAP; } });
+Object.defineProperty(exports, "W_NO_CONTRACT", { enumerable: true, get: function () { return score_core_js_2.W_NO_CONTRACT; } });
+Object.defineProperty(exports, "W_TRIFECTA", { enumerable: true, get: function () { return score_core_js_2.W_TRIFECTA; } });
+Object.defineProperty(exports, "gradeFor", { enumerable: true, get: function () { return score_core_js_2.gradeFor; } });
+Object.defineProperty(exports, "reportDeductions", { enumerable: true, get: function () { return score_core_js_2.reportDeductions; } });
+Object.defineProperty(exports, "isEmptyMachine", { enumerable: true, get: function () { return score_core_js_2.isEmptyMachine; } });
+Object.defineProperty(exports, "computeIntegrityScore", { enumerable: true, get: function () { return score_core_js_2.computeIntegrityScore; } });
+Object.defineProperty(exports, "scoreReport", { enumerable: true, get: function () { return score_core_js_2.scoreReport; } });
 /** The plugin's declared name (`.claude-plugin/plugin.json`), for a real label in
  * the ranking instead of a SHA-pinned dir basename. Falls back to the basename. */
 function pluginLabel(dir) {
@@ -41,233 +53,16 @@ function pluginLabel(dir) {
     }
     return (0, node_path_1.basename)(dir) || dir;
 }
-// Penalty weights — broken-at-runtime costs most, footguns less, nudges least.
-// Exported so the category view (audit-score.ts) reuses the SAME weights and the
-// two surfaces can never drift on a per-item cost.
-exports.W_MISSING_HOOK = 15; // a hook script that doesn't exist → never runs
-exports.W_NO_DESCRIPTION = 10; // a skill with no usable description → can't trigger
-exports.W_DANGLING_REF = 8; // a referenced intra-plugin file that's missing → broken path
-exports.W_OVERLAP = 8; // a description collision → the wrong skill fires
-exports.W_NO_CONTRACT = 5; // generic small-footgun weight (disallowedTools typo, invalid model/color)
-exports.W_TRIFECTA = 10; // a HARD lethal-trifecta contract (all three legs, explicit) → a prompt-injection exfil path. HALF the old 20: a DING, not a fail — a trifecta is a real risk worth surfacing in the grade, but official plugins ship the pattern by design, so it dents the score (e.g. feature-dev's 3 hard units → −30 → C) without a catastrophic F.
-// Two things are advisory, NOT graded penalties (shown, never scored — see scoreReport):
-//   - untested surfaces — a hardening gap, not breakage.
-//   - an agent that inherits all tools (no `tools:` line) — see reportDeductions for why.
-//   - an inherits-all (severity "advisory") trifecta finding — shown by the Safety
-//     ring but never scored; only the HARD, explicit all-three-legs finding grades.
-/** Map a 0–100 structural-health score to its letter grade (A ≥90 … F <60). */
-function gradeFor(score) {
-    if (score >= 90)
-        return "A";
-    if (score >= 80)
-        return "B";
-    if (score >= 70)
-        return "C";
-    if (score >= 60)
-        return "D";
-    return "F";
-}
-/**
- * The COMPLETE graded-penalty list a report incurs — the single source of truth
- * BOTH the leaderboard's single health number and the audit's category rings
- * read, so the overall can never drift between the two surfaces. Each entry is a
- * graded penalty; untested surfaces are deliberately ABSENT (they're advisory,
- * surfaced separately, never scored).
- */
-function reportDeductions(r) {
-    const missingHooks = r.hooks.filter((h) => h.status === "missing").length;
-    const noDesc = r.skills.filter((s) => !s.hasDescription).length;
-    const deadTools = r.agents.reduce((n, a) => n + a.toolIssues.length, 0);
-    const deadMcpTools = r.agents.reduce((n, a) => n + a.mcpToolIssues.length, 0);
-    const deadDisallowed = r.agents.reduce((n, a) => n + a.disallowedToolIssues.length, 0);
-    // HARD lethal-trifecta findings only — an EXPLICIT contract naming all three
-    // legs (a prompt-injection exfil path). Graded at W_TRIFECTA=10 (HALF the old
-    // 20): a DING that surfaces a real risk in the grade without a catastrophic F
-    // for an accepted design pattern official plugins ship. Advisory (inherits-all)
-    // trifecta findings are surfaced but NEVER graded (aligned with the inherits-all
-    // stance), so they're excluded here.
-    const hardTrifecta = r.trifectaFindings.filter((f) => f.finding.severity === "hard").length;
-    return [
-        {
-            n: hardTrifecta,
-            weight: exports.W_TRIFECTA,
-            label: "unit(s) holding all three lethal-trifecta legs (prompt-injection exfil path)",
-        },
-        {
-            n: missingHooks,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook script(s) MISSING",
-        },
-        {
-            n: r.hookEventIssues.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook(s) on an unknown event (never fire)",
-        },
-        {
-            n: noDesc,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "skill(s) with no usable description",
-        },
-        {
-            n: r.descriptionOverlaps.length,
-            weight: exports.W_OVERLAP,
-            label: "near-identical skill description(s) (wrong one fires)",
-        },
-        {
-            n: r.danglingRefs.length,
-            weight: exports.W_DANGLING_REF,
-            label: "broken intra-plugin reference(s)",
-        },
-        {
-            n: deadTools,
-            weight: exports.W_DANGLING_REF,
-            label: "agent tool(s) that don't exist (typo / never-available)",
-        },
-        {
-            n: deadMcpTools,
-            weight: exports.W_DANGLING_REF,
-            label: "agent MCP tool(s) whose server isn't declared (can't resolve)",
-        },
-        {
-            n: deadDisallowed,
-            weight: exports.W_NO_CONTRACT,
-            label: "agent disallowedTools typo(s) that block nothing",
-        },
-        // NB: an agent that inherits all tools (no `tools:` line) is ADVISORY, not a
-        // graded penalty — it's surfaced by scoreReport / the Structure ring but never
-        // drags the score. WHY: omitting the `tools:` line is a near-universal,
-        // legitimate authoring style (a measured OSS sweep of 122 real plugins found
-        // 109 whose ONLY finding was this), so penalizing it makes the grade cry wolf
-        // on idiomatic subagents. A health score should mean "something is BROKEN", and
-        // a broad-by-default tool surface is a hardening/least-privilege NUDGE, not
-        // breakage. The count is re-derived where the advisory note is built.
-        {
-            n: r.frontmatterIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "surface(s) missing required frontmatter (name/description)",
-        },
-        {
-            n: r.frontmatterValueIssues.length,
-            weight: exports.W_NO_CONTRACT,
-            label: "agent(s) with an invalid model/color (typo → silent fallback)",
-        },
-        {
-            n: r.mcpIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "MCP server(s) that can't start (no command/url)",
-        },
-        {
-            n: r.mcpHookIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "mcp_tool hook(s) incomplete / targeting an undeclared server",
-        },
-        {
-            n: r.skillResourceIssues.length,
-            weight: exports.W_DANGLING_REF,
-            label: "skill bundled-resource ref(s) that don't resolve on disk",
-        },
-        {
-            n: r.skillFenceIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "invisible skill(s) (frontmatter with no opening `---` fence)",
-        },
-        {
-            n: r.pluginLayoutIssues.length,
-            weight: exports.W_NO_DESCRIPTION,
-            label: "functional dir(s) misplaced inside `.claude-plugin/` (invisible)",
-        },
-        {
-            n: r.hookBlockFindings.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook(s) that look like they block but silently don't",
-        },
-        {
-            n: r.hookMatcherFindings.length,
-            weight: exports.W_MISSING_HOOK,
-            label: "hook matcher(s) that never fire (typo / wrong MCP form)",
-        },
-        // NB: delegationTrifecta (like the advisory per-unit/inherits-all trifecta) is a
-        // ⚠ RISK, surfaced but NOT graded — only the HARD per-unit trifecta above scores.
-        // NB: untested surfaces are NOT a penalty — an untested surface is a hardening
-        // gap, not breakage, so it never drags the health score (it's appended as an
-        // advisory note below). The score ranks what's BROKEN.
-    ];
-}
-/** True when a report has no loadable plugin surface at all (the empty machine). */
-function isEmptyMachine(r) {
-    const surfaces = r.skills.length +
-        r.agents.length +
-        r.hooks.length +
-        r.inlineHooks +
-        r.commands;
-    return surfaces === 0 && !r.mcp;
-}
-/**
- * THE shared integrity score — `100 − Σ(all graded penalties)`, clamped to
- * [0,100]. Both the leaderboard's single health number AND the audit's headline
- * overall read this, so the two can never disagree (the summed model is the
- * honest one — averaging rings would dilute a real problem). Returns the score
- * plus the per-item deductions so callers render their own issue/finding lists.
- */
-function computeIntegrityScore(deductions) {
-    let penalty = 0;
-    for (const d of deductions) {
-        if (d.n <= 0)
-            continue;
-        penalty += d.n * d.weight;
-    }
-    return { score: Math.max(0, 100 - penalty), penalty };
-}
-/** Resolve the terse "thing(s)" plural placeholder against a count:
- * n===1 drops the "(s)" ("1 tool"); otherwise it becomes "s" ("3 tools").
- * (Kept local — audit-score.ts has its own copy to avoid a circular import.) */
-function pluralizeLabel(n, label) {
-    return label.replace(/\(s\)/g, n === 1 ? "" : "s");
-}
-/** Deterministic structural-health score for one scanned plugin. */
-function scoreReport(r) {
-    // An empty/unloadable machine isn't healthy — it's a non-plugin or a broken
-    // load. A command-only or MCP-only plugin (commands/*.md or .mcp.json with no
-    // skills/agents/hooks) IS a legitimate plugin, though — Anthropic ships
-    // command-only plugins in its own marketplace — so it must NOT score 0.
-    const surfaces = r.skills.length + r.agents.length + r.hooks.length + r.commands;
-    if (surfaces === 0 && !r.mcp) {
-        return { score: 0, issues: ["no loadable plugin surface"] };
-    }
-    const deductions = reportDeductions(r);
-    const { score } = computeIntegrityScore(deductions);
-    const issues = [];
-    for (const d of deductions) {
-        if (d.n === 0)
-            continue;
-        issues.push(`${String(d.n)} ${pluralizeLabel(d.n, d.label)}`);
-    }
-    // Sort issues by cost (worst first) so the report leads with what matters.
-    issues.sort((a, b) => Number(b.split(" ")[0]) - Number(a.split(" ")[0]));
-    // Advisory notes are surfaced for visibility but DON'T affect the score, so they
-    // come AFTER the real (score-affecting) issues:
-    //   - inherit-all (no tool contract): a least-privilege NUDGE, not breakage —
-    //     see reportDeductions for the full rationale.
-    //   - untested surfaces: a hardening gap, not breakage.
-    const noContract = r.agents.filter((a) => a.tools === null).length;
-    if (noContract > 0) {
-        issues.push(`${String(noContract)} ${pluralizeLabel(noContract, "agent(s) inherit all tools (no contract) (advisory)")}`);
-    }
-    if (r.untested > 0) {
-        issues.push(`${String(r.untested)} ${pluralizeLabel(r.untested, "untested surface(s) (advisory)")}`);
-    }
-    return { score, issues };
-}
 /** Scan + score each directory, ranked best-first (ties broken by name). */
 function rankPlugins(dirs) {
     const scored = dirs.map((dir) => {
         const report = (0, scan_js_1.scanPlugin)(dir);
-        const { score, issues } = scoreReport(report);
+        const { score, issues } = (0, score_core_js_1.scoreReport)(report);
         return {
             dir,
             name: pluginLabel(dir),
             score,
-            grade: gradeFor(score),
+            grade: (0, score_core_js_1.gradeFor)(score),
             issues,
             report,
         };

package/dist/optimize.d.ts

@@ -26,7 +26,7 @@
  * the ranked fix list + the hand-off to the measured layer. Same findings, the
  * optimization framing. See research/measurement-authority.md (A2) + roadmap §P1.
  */
-import { type PluginScore } from "./leaderboard.js";
+import { type PluginScore } from "./score-core.js";
 import { type ExplanationConfidence } from "./score-explainer.js";
 import type { ScanReport } from "./scan.js";
 /**

package/dist/optimize.js

@@ -31,7 +31,7 @@ exports.formatOptimize = formatOptimize;
  * the ranked fix list + the hand-off to the measured layer. Same findings, the
  * optimization framing. See research/measurement-authority.md (A2) + roadmap §P1.
  */
-const leaderboard_js_1 = require("./leaderboard.js");
+const score_core_js_1 = require("./score-core.js");
 const score_explainer_js_1 = require("./score-explainer.js");
 function actionFor(e) {
     return e.symptom === "wrong-skill-fires" ? "differentiate" : "fix";
@@ -46,7 +46,7 @@ function isEmptyMachine(r) {
  * before `possible` proxies, via explainScore's own ordering). Pure over the report.
  */
 function optimize(report) {
-    const { score } = (0, leaderboard_js_1.scoreReport)(report);
+    const { score } = (0, score_core_js_1.scoreReport)(report);
     const recommendations = (0, score_explainer_js_1.explainScore)(report).map((e) => ({
         surface: e.surface,
         action: actionFor(e),
@@ -58,7 +58,7 @@ function optimize(report) {
     return {
         dir: report.dir,
         score,
-        grade: (0, leaderboard_js_1.gradeFor)(score),
+        grade: (0, score_core_js_1.gradeFor)(score),
         recommendations,
         empty: isEmptyMachine(report),
     };

package/dist/posix-path.d.ts

@@ -0,0 +1,40 @@
+/**
+ * A tiny, node-free POSIX `path` — the browser-safe substitute for `node:path`
+ * inside the in-browser audit engine (`scan-core.ts` / `scan-files.ts` /
+ * `test-coverage-files.ts` and the core detectors they reach). A Vite bundle of
+ * that engine must not pull `node:path`, so these are pure string ops.
+ *
+ * The audit engine's file-map keys are always POSIX (`/`-separated), and the
+ * disk-side `scanPlugin` feeds it absolute POSIX roots (`resolve(dir)` on Linux),
+ * so a faithful port of Node's `path.posix` algorithm is byte-identical to
+ * `node:path` for every input the engine passes — which is exactly what the
+ * parity firewall (`scan-files.test.ts`) proves. `resolve` deliberately falls
+ * back to `/` (never `process.cwd()`) so it stays pure and process-free; every
+ * call site passes an absolute first segment, so the fallback is never reached.
+ *
+ * NOTE — the functions below are VERBATIM ports of Node's `lib/path.js` POSIX
+ * implementations (charCode scan, `normalizeString`, `basename`, `relative`).
+ * Their branch depth / cyclomatic complexity is inherent to that battle-tested
+ * algorithm; rewriting it to satisfy the complexity linters would risk a subtle
+ * behavioural divergence from `node:path` (which the disk-vs-browser parity gate
+ * relies on), so the metric rules are disabled for this file only.
+ */
+/** POSIX `path.isAbsolute`. */
+export declare function isAbsolute(path: string): boolean;
+/** POSIX `path.normalize`. */
+export declare function normalize(path: string): string;
+/** POSIX `path.join`. */
+export declare function join(...parts: string[]): string;
+/**
+ * POSIX `path.resolve`. Right-to-left until an absolute segment is found, then
+ * normalize. The `i === -1` fallback is `/` (not `process.cwd()`) so this stays
+ * pure; every engine call site passes an absolute first segment.
+ */
+export declare function resolve(...parts: string[]): string;
+/** POSIX `path.dirname`. */
+export declare function dirname(path: string): string;
+/** POSIX `path.basename` (with an optional `suffix` to strip, like `node:path`). */
+export declare function basename(path: string, suffix?: string): string;
+/** POSIX `path.relative`. */
+export declare function relative(from: string, to: string): string;
+//# sourceMappingURL=posix-path.d.ts.map

package/dist/posix-path.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * A tiny, node-free POSIX `path` — the browser-safe substitute for `node:path`
+ * inside the in-browser audit engine (`scan-core.ts` / `scan-files.ts` /
+ * `test-coverage-files.ts` and the core detectors they reach). A Vite bundle of
+ * that engine must not pull `node:path`, so these are pure string ops.
+ *
+ * The audit engine's file-map keys are always POSIX (`/`-separated), and the
+ * disk-side `scanPlugin` feeds it absolute POSIX roots (`resolve(dir)` on Linux),
+ * so a faithful port of Node's `path.posix` algorithm is byte-identical to
+ * `node:path` for every input the engine passes — which is exactly what the
+ * parity firewall (`scan-files.test.ts`) proves. `resolve` deliberately falls
+ * back to `/` (never `process.cwd()`) so it stays pure and process-free; every
+ * call site passes an absolute first segment, so the fallback is never reached.
+ *
+ * NOTE — the functions below are VERBATIM ports of Node's `lib/path.js` POSIX
+ * implementations (charCode scan, `normalizeString`, `basename`, `relative`).
+ * Their branch depth / cyclomatic complexity is inherent to that battle-tested
+ * algorithm; rewriting it to satisfy the complexity linters would risk a subtle
+ * behavioural divergence from `node:path` (which the disk-vs-browser parity gate
+ * relies on), so the metric rules are disabled for this file only.
+ */
+/* eslint-disable complexity, max-depth, sonarjs/cognitive-complexity, sonarjs/nested-control-flow */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAbsolute = isAbsolute;
+exports.normalize = normalize;
+exports.join = join;
+exports.resolve = resolve;
+exports.dirname = dirname;
+exports.basename = basename;
+exports.relative = relative;
+const SLASH = 47; // '/'
+const DOT = 46; // '.'
+/**
+ * The core POSIX normalize pass (ported from Node's `normalizeString`): collapse
+ * `.`/`..`/`//` in a slash-separated path with no leading root. `allowAboveRoot`
+ * keeps leading `..` segments (used for a relative path).
+ */
+function normalizeString(path, allowAboveRoot) {
+    let res = "";
+    let lastSegmentLength = 0;
+    let lastSlash = -1;
+    let dots = 0;
+    let code = 0;
+    for (let i = 0; i <= path.length; ++i) {
+        if (i < path.length)
+            code = path.charCodeAt(i);
+        else if (code === SLASH)
+            break;
+        else
+            code = SLASH;
+        if (code === SLASH) {
+            if (lastSlash === i - 1 || dots === 1) {
+                // no-op: a `//` or `.` segment
+            }
+            else if (dots === 2) {
+                if (res.length < 2 ||
+                    lastSegmentLength !== 2 ||
+                    res.charCodeAt(res.length - 1) !== DOT ||
+                    res.charCodeAt(res.length - 2) !== DOT) {
+                    if (res.length > 2) {
+                        const lastSlashIndex = res.lastIndexOf("/");
+                        if (lastSlashIndex === -1) {
+                            res = "";
+                            lastSegmentLength = 0;
+                        }
+                        else {
+                            res = res.slice(0, lastSlashIndex);
+                            lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                        }
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                    else if (res.length !== 0) {
+                        res = "";
+                        lastSegmentLength = 0;
+                        lastSlash = i;
+                        dots = 0;
+                        continue;
+                    }
+                }
+                if (allowAboveRoot) {
+                    res += res.length > 0 ? "/.." : "..";
+                    lastSegmentLength = 2;
+                }
+            }
+            else {
+                if (res.length > 0)
+                    res += "/" + path.slice(lastSlash + 1, i);
+                else
+                    res = path.slice(lastSlash + 1, i);
+                lastSegmentLength = i - lastSlash - 1;
+            }
+            lastSlash = i;
+            dots = 0;
+        }
+        else if (code === DOT && dots !== -1) {
+            ++dots;
+        }
+        else {
+            dots = -1;
+        }
+    }
+    return res;
+}
+/** POSIX `path.isAbsolute`. */
+function isAbsolute(path) {
+    return path.length > 0 && path.charCodeAt(0) === SLASH;
+}
+/** POSIX `path.normalize`. */
+function normalize(path) {
+    if (path.length === 0)
+        return ".";
+    const isAbs = path.charCodeAt(0) === SLASH;
+    const trailingSep = path.charCodeAt(path.length - 1) === SLASH;
+    path = normalizeString(path, !isAbs);
+    if (path.length === 0) {
+        if (isAbs)
+            return "/";
+        return trailingSep ? "./" : ".";
+    }
+    if (trailingSep)
+        path += "/";
+    return isAbs ? `/${path}` : path;
+}
+/** POSIX `path.join`. */
+function join(...parts) {
+    if (parts.length === 0)
+        return ".";
+    let joined;
+    for (const part of parts) {
+        if (part.length > 0) {
+            if (joined === undefined)
+                joined = part;
+            else
+                joined += `/${part}`;
+        }
+    }
+    if (joined === undefined)
+        return ".";
+    return normalize(joined);
+}
+/**
+ * POSIX `path.resolve`. Right-to-left until an absolute segment is found, then
+ * normalize. The `i === -1` fallback is `/` (not `process.cwd()`) so this stays
+ * pure; every engine call site passes an absolute first segment.
+ */
+function resolve(...parts) {
+    let resolvedPath = "";
+    let resolvedAbsolute = false;
+    for (let i = parts.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        const path = i >= 0 ? parts[i] : "/";
+        if (path.length === 0)
+            continue;
+        resolvedPath = `${path}/${resolvedPath}`;
+        resolvedAbsolute = path.charCodeAt(0) === SLASH;
+    }
+    resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+    if (resolvedAbsolute)
+        return `/${resolvedPath}`;
+    return resolvedPath.length > 0 ? resolvedPath : ".";
+}
+/** POSIX `path.dirname`. */
+function dirname(path) {
+    if (path.length === 0)
+        return ".";
+    const hasRoot = path.charCodeAt(0) === SLASH;
+    let end = -1;
+    let matchedSlash = true;
+    for (let i = path.length - 1; i >= 1; --i) {
+        if (path.charCodeAt(i) === SLASH) {
+            if (!matchedSlash) {
+                end = i;
+                break;
+            }
+        }
+        else {
+            matchedSlash = false;
+        }
+    }
+    if (end === -1)
+        return hasRoot ? "/" : ".";
+    if (hasRoot && end === 1)
+        return "//";
+    return path.slice(0, end);
+}
+/** POSIX `path.basename` (with an optional `suffix` to strip, like `node:path`). */
+function basename(path, suffix) {
+    let start = 0;
+    let end = -1;
+    let matchedSlash = true;
+    if (suffix !== undefined &&
+        suffix.length > 0 &&
+        suffix.length <= path.length) {
+        if (suffix === path)
+            return "";
+        let extIdx = suffix.length - 1;
+        let firstNonSlashEnd = -1;
+        for (let i = path.length - 1; i >= 0; --i) {
+            const code = path.charCodeAt(i);
+            if (code === SLASH) {
+                if (!matchedSlash) {
+                    start = i + 1;
+                    break;
+                }
+            }
+            else {
+                if (firstNonSlashEnd === -1) {
+                    matchedSlash = false;
+                    firstNonSlashEnd = i + 1;
+                }
+                if (extIdx >= 0) {
+                    if (code === suffix.charCodeAt(extIdx)) {
+                        if (--extIdx === -1) {
+                            end = i;
+                        }
+                    }
+                    else {
+                        extIdx = -1;
+                        end = firstNonSlashEnd;
+                    }
+                }
+            }
+        }
+        if (start === end)
+            end = firstNonSlashEnd;
+        else if (end === -1)
+            end = path.length;
+        return path.slice(start, end);
+    }
+    for (let i = path.length - 1; i >= 0; --i) {
+        if (path.charCodeAt(i) === SLASH) {
+            if (!matchedSlash) {
+                start = i + 1;
+                break;
+            }
+        }
+        else if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+        }
+    }
+    if (end === -1)
+        return "";
+    return path.slice(start, end);
+}
+/** POSIX `path.relative`. */
+function relative(from, to) {
+    if (from === to)
+        return "";
+    from = resolve(from);
+    to = resolve(to);
+    if (from === to)
+        return "";
+    const fromStart = 1;
+    const fromEnd = from.length;
+    const fromLen = fromEnd - fromStart;
+    const toStart = 1;
+    const toLen = to.length - toStart;
+    const length = fromLen < toLen ? fromLen : toLen;
+    let lastCommonSep = -1;
+    let i = 0;
+    for (; i < length; i++) {
+        const fromCode = from.charCodeAt(fromStart + i);
+        if (fromCode !== to.charCodeAt(toStart + i))
+            break;
+        else if (fromCode === SLASH)
+            lastCommonSep = i;
+    }
+    if (i === length) {
+        if (toLen > length) {
+            if (to.charCodeAt(toStart + i) === SLASH)
+                return to.slice(toStart + i + 1);
+            if (i === 0)
+                return to.slice(toStart + i);
+        }
+        else if (fromLen > length) {
+            if (from.charCodeAt(fromStart + i) === SLASH)
+                lastCommonSep = i;
+            else if (i === 0)
+                lastCommonSep = 0;
+        }
+    }
+    let out = "";
+    for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd || from.charCodeAt(i) === SLASH) {
+            out += out.length === 0 ? ".." : "/..";
+        }
+    }
+    return `${out}${to.slice(toStart + lastCommonSep)}`;
+}
+//# sourceMappingURL=posix-path.js.map