@hominis/fireforge 0.54.0 → 0.60.0

package/dist/src/core/patch-lint-ownership.js

@@ -1,125 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Patch ownership resolution for JS-shaped files.
- *
- * A file is "patch-owned" when it was created by the project's patch
- * queue rather than being an upstream Firefox file that happens to be
- * modified. This module computes the set of patch-owned paths so lint
- * rules can scope enforcement to project code only.
- *
- * The two resolvers are kept separate (one per extension predicate)
- * because the downstream rules differ: `.sys.mjs` files go through
- * `runCheckJs` (TypeScript checkJs) and the export-walker JSDoc rule,
- * while chrome subscripts (`.js` non-`.sys.mjs`) only get the
- * script-walker JSDoc rule. Mixing them in a single set would silently broaden
- * `runCheckJs` to chrome subscripts, which it is not designed for.
- */
-import { collectNewFileCreatorsByPath } from './patch-lint-cross.js';
-/**
- * Returns the set of patch-owned files matching `predicate`. Internal
- * helper shared by the per-extension resolvers below.
- */
-function resolveOwned(currentNewFiles, patchQueueCtx, predicate) {
-    const owned = new Set();
-    for (const file of currentNewFiles) {
-        if (predicate(file)) {
-            owned.add(file);
-        }
-    }
-    if (patchQueueCtx) {
-        const creators = collectNewFileCreatorsByPath(patchQueueCtx);
-        for (const [file, owners] of creators) {
-            if (predicate(file) && owners.length > 0) {
-                owned.add(file);
-            }
-        }
-    }
-    return owned;
-}
-/**
- * Returns the set of file paths that are patch-owned `.sys.mjs` files.
- *
- * A file is patch-owned if:
- * 1. It is newly created in the current diff, OR
- * 2. It was created by an existing patch already in the queue.
- *
- * When no queue context is provided the result is limited to (1),
- * which matches the pre-ownership behavior and keeps callers that
- * do not have access to the patches directory working correctly.
- *
- * @param currentNewFiles - Files newly created in the current diff
- * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
- * @returns Set of patch-owned `.sys.mjs` file paths
- */
-export function resolvePatchOwnedSysMjs(currentNewFiles, patchQueueCtx) {
-    return resolveOwned(currentNewFiles, patchQueueCtx, (file) => file.endsWith('.sys.mjs'));
-}
-/**
- * Returns the set of file paths that are patch-owned chrome subscripts
- * (`.js` files that are not `.sys.mjs` modules, typically
- * `browser/base/content/<binaryName>*.js` and similar). Same ownership
- * semantics as {@link resolvePatchOwnedSysMjs}.
- *
- * @param currentNewFiles - Files newly created in the current diff
- * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
- * @returns Set of patch-owned chrome-subscript file paths
- */
-export function resolvePatchOwnedChromeScripts(currentNewFiles, patchQueueCtx) {
-    return resolveOwned(currentNewFiles, patchQueueCtx, (file) => file.endsWith('.js') && !file.endsWith('.sys.mjs'));
-}
-/**
- * Test-script predicate for the `checkJsTestFiles` pass:
- * plain `.js` files (not `.sys.mjs` modules) that live under a `/test/`
- * path or carry a `browser_` / `test_` / `xpcshell_` basename. Duplicates
- * `patch-lint.ts`'s `isTestFile` shape rather than importing it:
- * patch-lint.ts imports this module, so the reverse edge would create an
- * import cycle (dpdm gate). The agreement is pinned by
- * `patch-lint-ownership.test.ts`.
- */
-export function isTestScriptFile(file) {
-    if (!file.endsWith('.js') || file.endsWith('.sys.mjs'))
-        return false;
-    if (file.includes('/test/'))
-        return true;
-    const basename = file.split('/').pop() ?? '';
-    return /^(?:browser_|test_|xpcshell_).*\.js$/.test(basename);
-}
-/**
- * For each test script, the ES modules (`.mjs`, `.sys.mjs`) the queue
- * creates up to and including the test's own patch: what its imports can
- * resolve to in a per-test checkJs program. A test no patch touches sees
- * every module the queue creates.
- *
- * @param patchQueueCtx - The queue, in apply order
- * @returns Lookup from a test script path to its resolvable modules
- */
-export function resolvableModulesForTests(patchQueueCtx) {
-    const byTest = new Map();
-    const upTo = new Set();
-    for (const entry of patchQueueCtx.entries) {
-        for (const file of entry.newFiles.keys()) {
-            if (file.endsWith('.mjs') && !isTestScriptFile(file))
-                upTo.add(file);
-        }
-        const snapshot = new Set(upTo);
-        for (const file of [...entry.newFiles.keys(), ...entry.modifiedFileAdditions.keys()]) {
-            if (isTestScriptFile(file) && !byTest.has(file))
-                byTest.set(file, snapshot);
-        }
-    }
-    const all = upTo;
-    return (testFile) => byTest.get(testFile) ?? all;
-}
-/**
- * Returns the set of patch-owned test `.js` files. Same
- * ownership semantics as {@link resolvePatchOwnedSysMjs}. Consumed by the
- * `patchLint.checkJsTestFiles` pass, which checks each as its own small
- * script-scope program.
- *
- * @param currentNewFiles - Files newly created in the current diff
- * @param patchQueueCtx - Optional cross-patch context for queue-wide ownership
- * @returns Set of patch-owned test-script file paths
- */
-export function resolvePatchOwnedTestScripts(currentNewFiles, patchQueueCtx) {
-    return resolveOwned(currentNewFiles, patchQueueCtx, isTestScriptFile);
-}

package/dist/src/core/patch-lint-prettier.d.ts

@@ -1,34 +0,0 @@
-/**
- * Optional Prettier pass over patch-owned `.sys.mjs` modules.
- *
- * Without this pass no tier of the chain runs Prettier on `.sys.mjs`, so
- * module formatting drift survives to a human reviewer. The obvious manual
- * check is misleading in the same direction: a fork's root `.prettierignore` typically excludes `engine/`,
- * so `prettier --check --config engine/.prettierrc.js <engine files>` run
- * from the repo root reports "all files use Prettier code style" for files
- * that fail the identical check run from inside `engine/`.
- *
- * This pass therefore runs prettier with `cwd` set to the engine directory,
- * so the engine's own `.prettierrc*` and `.prettierignore` resolve the way
- * they do for anyone working in that tree, and the FireForge result agrees
- * with the operator's own command.
- *
- * Opt-in (`patchLint.prettier`, default `'off'`): it spawns a process per
- * lint and is a new failure surface on queues that never had one. When it
- * is off, formatting is explicitly out of scope for the per-patch tier.
- * That is the contract, not an accident.
- */
-import type { PatchLintIssue } from '../types/commands/index.js';
-import type { PatchLintSeverityGate } from '../types/config.js';
-/**
- * Runs `prettier --check` over `files` from inside the engine directory.
- *
- * @param engineDir - Absolute engine directory. Also the `cwd`, which is
- *   what makes the engine's own config and ignore file authoritative
- * @param projectRoot - FireForge project root, for the fallback binary
- * @param files - Engine-relative patch-owned `.sys.mjs` paths
- * @param gate - Severity for reported issues. `'off'` skips the pass
- * @returns One issue per unformatted file, or a single run-level issue when
- *   prettier could not be run at all
- */
-export declare function invokePatchLintPrettier(engineDir: string, projectRoot: string, files: readonly string[], gate: PatchLintSeverityGate): Promise<PatchLintIssue[]>;

package/dist/src/core/patch-lint-prettier.js

@@ -1,124 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Optional Prettier pass over patch-owned `.sys.mjs` modules.
- *
- * Without this pass no tier of the chain runs Prettier on `.sys.mjs`, so
- * module formatting drift survives to a human reviewer. The obvious manual
- * check is misleading in the same direction: a fork's root `.prettierignore` typically excludes `engine/`,
- * so `prettier --check --config engine/.prettierrc.js <engine files>` run
- * from the repo root reports "all files use Prettier code style" for files
- * that fail the identical check run from inside `engine/`.
- *
- * This pass therefore runs prettier with `cwd` set to the engine directory,
- * so the engine's own `.prettierrc*` and `.prettierignore` resolve the way
- * they do for anyone working in that tree, and the FireForge result agrees
- * with the operator's own command.
- *
- * Opt-in (`patchLint.prettier`, default `'off'`): it spawns a process per
- * lint and is a new failure surface on queues that never had one. When it
- * is off, formatting is explicitly out of scope for the per-patch tier.
- * That is the contract, not an accident.
- */
-import { join } from 'node:path';
-import { toError } from '../utils/errors.js';
-import { pathExists } from '../utils/fs.js';
-import { verbose } from '../utils/logger.js';
-import { exec } from '../utils/process.js';
-/** How long prettier gets before the pass gives up (ms). */
-const PRETTIER_TIMEOUT_MS = 120_000;
-/** Prettier's per-file `--check` failure line. */
-const PRETTIER_WARN_LINE = /^\[warn]\s+(.+)$/;
-/** Summary lines prettier prints alongside the per-file ones. */
-const PRETTIER_SUMMARY_LINE = /^\[warn]\s+(?:Code style issues|Forgot to run)/;
-/**
- * Finds prettier, preferring a binary installed in the tree being checked.
- *
- * Order matters: the engine's own `node_modules` is the install whose
- * version matches the engine's config, the project's is the next best
- * guess, and `npx` is the last resort (it can download, so it is never
- * preferred over something already present).
- */
-async function resolvePrettier(engineDir, projectRoot) {
-    for (const root of [engineDir, projectRoot]) {
-        const candidate = join(root, 'node_modules', '.bin', 'prettier');
-        if (await pathExists(candidate)) {
-            return { command: candidate, prefixArgs: [] };
-        }
-    }
-    return { command: 'npx', prefixArgs: ['--no-install', 'prettier'] };
-}
-/**
- * Runs `prettier --check` over `files` from inside the engine directory.
- *
- * @param engineDir - Absolute engine directory. Also the `cwd`, which is
- *   what makes the engine's own config and ignore file authoritative
- * @param projectRoot - FireForge project root, for the fallback binary
- * @param files - Engine-relative patch-owned `.sys.mjs` paths
- * @param gate - Severity for reported issues. `'off'` skips the pass
- * @returns One issue per unformatted file, or a single run-level issue when
- *   prettier could not be run at all
- */
-export async function invokePatchLintPrettier(engineDir, projectRoot, files, gate) {
-    if (gate === 'off' || files.length === 0)
-        return [];
-    const severity = gate === 'error' ? 'error' : 'warning';
-    const invocation = await resolvePrettier(engineDir, projectRoot);
-    let result;
-    try {
-        result = await exec(invocation.command, [...invocation.prefixArgs, '--check', ...files], {
-            cwd: engineDir,
-            timeout: PRETTIER_TIMEOUT_MS,
-        });
-    }
-    catch (error) {
-        return [
-            {
-                file: '(prettier)',
-                check: 'prettier-format',
-                message: `patchLint.prettier is enabled but prettier could not be run (${toError(error).message}). ` +
-                    'Install prettier in engine/ or the project root, or set "patchLint.prettier": "off".',
-                severity,
-            },
-        ];
-    }
-    // Exit 0: everything formatted. Exit 1: at least one file differs. Any
-    // other code is prettier failing (bad config, unparseable file), which is
-    // a different finding and must not be reported as formatting drift.
-    if (result.exitCode === 0)
-        return [];
-    const output = `${result.stderr}\n${result.stdout}`;
-    if (result.exitCode !== 1) {
-        return [
-            {
-                file: '(prettier)',
-                check: 'prettier-format',
-                message: `prettier exited ${result.exitCode} without completing the check: ` +
-                    output.trim().split('\n').slice(-5).join(' ').slice(0, 400),
-                severity,
-            },
-        ];
-    }
-    const unformatted = new Set();
-    for (const line of output.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (PRETTIER_SUMMARY_LINE.test(trimmed))
-            continue;
-        const match = PRETTIER_WARN_LINE.exec(trimmed);
-        const file = match?.[1]?.trim();
-        if (file !== undefined && file.length > 0)
-            unformatted.add(file);
-    }
-    if (unformatted.size === 0) {
-        verbose('patchLint.prettier: prettier exited 1 but named no file; reporting nothing.');
-        return [];
-    }
-    return [...unformatted].sort().map((file) => ({
-        file,
-        check: 'prettier-format',
-        message: `Not formatted per the project's Prettier configuration. Checked from inside engine/, ` +
-            `so engine/.prettierrc* and engine/.prettierignore apply — the same command run from the ` +
-            `repo root can report a false pass when the root .prettierignore excludes engine/. ` +
-            `Fix with "prettier --write ${file}" run from engine/.`,
-        severity,
-    }));
-}

package/dist/src/core/patch-lint-projection.d.ts

@@ -1,25 +0,0 @@
-import type { PatchLintIssue } from '../types/commands/index.js';
-/**
- * Diffs projected lint issues against the baseline and returns those
- * considered "new" regressions.
- *
- * The equality key is the issue fingerprint when present, otherwise the
- * full `(check, file, message)` triple. Fingerprints are emitted by rules
- * whose message text can drift between otherwise-equivalent runs (for
- * example because the message embeds later-owner filenames or positional
- * detail). Falling back to the full tuple keeps the helper conservative
- * for non-fingerprinted rules: if their message changes, we would
- * rather surface a potential regression than silently swallow it.
- *
- * Consumption order within the projected list is stable (the input
- * order is preserved), so when baseline has N issues for a key and
- * projected has N+M for the same key, the *last* M projected issues on
- * that key are reported as regressions. That keeps the reporting
- * deterministic and gives the operator at least one concrete message
- * per regression even when only counts differ.
- *
- * @param baseline - Error-severity issues from the current queue
- * @param projected - Error-severity issues from the projected queue
- * @returns Subset of `projected` not matched by a baseline counterpart
- */
-export declare function computeProjectedLintRegressions(baseline: PatchLintIssue[], projected: PatchLintIssue[]): PatchLintIssue[];

package/dist/src/core/patch-lint-projection.js

@@ -1,43 +0,0 @@
-/**
- * Diffs projected lint issues against the baseline and returns those
- * considered "new" regressions.
- *
- * The equality key is the issue fingerprint when present, otherwise the
- * full `(check, file, message)` triple. Fingerprints are emitted by rules
- * whose message text can drift between otherwise-equivalent runs (for
- * example because the message embeds later-owner filenames or positional
- * detail). Falling back to the full tuple keeps the helper conservative
- * for non-fingerprinted rules: if their message changes, we would
- * rather surface a potential regression than silently swallow it.
- *
- * Consumption order within the projected list is stable (the input
- * order is preserved), so when baseline has N issues for a key and
- * projected has N+M for the same key, the *last* M projected issues on
- * that key are reported as regressions. That keeps the reporting
- * deterministic and gives the operator at least one concrete message
- * per regression even when only counts differ.
- *
- * @param baseline - Error-severity issues from the current queue
- * @param projected - Error-severity issues from the projected queue
- * @returns Subset of `projected` not matched by a baseline counterpart
- */
-export function computeProjectedLintRegressions(baseline, projected) {
-    const issueKey = (i) => i.fingerprint ?? `${i.check}|${i.file}|${i.message}`;
-    const baselineCounts = new Map();
-    for (const issue of baseline) {
-        const key = issueKey(issue);
-        baselineCounts.set(key, (baselineCounts.get(key) ?? 0) + 1);
-    }
-    const regressions = [];
-    const consumedByKey = new Map();
-    for (const issue of projected) {
-        const key = issueKey(issue);
-        const allowed = baselineCounts.get(key) ?? 0;
-        const consumed = consumedByKey.get(key) ?? 0;
-        if (consumed >= allowed) {
-            regressions.push(issue);
-        }
-        consumedByKey.set(key, consumed + 1);
-    }
-    return regressions;
-}

package/dist/src/core/patch-lint-queue-types.d.ts

@@ -1,60 +0,0 @@
-/**
- * Structural views of the cross-patch lint queue context.
- *
- * A leaf module by design: it imports nothing, so the individual rule
- * modules can describe the slice of `PatchQueueContext` they read without
- * importing `patch-lint-cross.ts` (which imports them back). Sharing them
- * here instead of re-declaring a private `{ entries }` interface per rule
- * keeps the dependency edge one-way and `dpdm` clean while stating the shape
- * once.
- */
-/**
- * The slice of a queue entry consumed by rules that read raw patch bodies
- * (the new-file creators map, the binary-body check).
- */
-export interface PatchQueueBodyEntry {
-    /** Filename on disk and in the manifest. */
-    filename: string;
-    /** Raw unified-diff content of the patch body. */
-    diff: string;
-}
-/**
- * The slice of a queue entry consumed by the module-registration rule: the
- * per-path content maps rather than the raw diff.
- */
-export interface PatchQueueRegistrationEntry {
-    /** Filename on disk and in the manifest. */
-    filename: string;
-    /** Newly-created file path → the content the patch would produce. */
-    newFiles: ReadonlyMap<string, string>;
-    /** Existing file path → the lines the patch adds to it. */
-    modifiedFileAdditions: ReadonlyMap<string, string>;
-}
-/**
- * Structural queue view: the `entries` field of a `PatchQueueContext`,
- * narrowed to whichever entry slice a rule needs.
- */
-export interface PatchQueueView<TEntry> {
-    /** Entries in application order (lowest `order` first). */
-    entries: readonly TEntry[];
-}
-/**
- * The slice consumed by the forward-registration rule: the same content maps
- * the module-registration rule reads, plus the body-kind-agnostic creation
- * set and the ordering/metadata needed to decide "later" and "declared".
- */
-export interface PatchQueueForwardRegistrationEntry extends PatchQueueRegistrationEntry {
-    /** Order number from the manifest (or filename prefix fallback). */
-    order: number;
-    /** Every path this patch creates, whatever the body kind. */
-    createdFiles: ReadonlySet<string>;
-    /** Manifest metadata. Null when the patch file exists but has no entry. */
-    metadata: {
-        stagedDependencies?: {
-            registrations?: readonly {
-                file: string;
-                creates: string;
-            }[];
-        };
-    } | null;
-}

package/dist/src/core/patch-lint-queue-types.js

@@ -1,12 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * Structural views of the cross-patch lint queue context.
- *
- * A leaf module by design: it imports nothing, so the individual rule
- * modules can describe the slice of `PatchQueueContext` they read without
- * importing `patch-lint-cross.ts` (which imports them back). Sharing them
- * here instead of re-declaring a private `{ entries }` interface per rule
- * keeps the dependency edge one-way and `dpdm` clean while stating the shape
- * once.
- */
-export {};

package/dist/src/core/patch-lint-size-thresholds.d.ts

@@ -1,52 +0,0 @@
-/**
- * The patch-size thresholds (`large-patch-lines`, `large-patch-files`) and
- * their merge with `patchLint.patchSizeThresholds`.
- *
- * Its own dependency-free module for the same reason as
- * `patch-lint-file-size.ts`: the config validator checks an override
- * against the merged result, and importing the rule bodies from config
- * parsing would draw an import cycle.
- */
-import type { PatchLintPatchSizeThresholds } from '../types/config.js';
-import type { ResolvedFileSizeTier } from './patch-lint-file-size.js';
-/** The tiers a patch is measured against. */
-export type PatchSizeTierName = 'general' | 'test' | 'branding';
-/**
- * A resolved `large-patch-files` triple. `error` is `null` when no error
- * band is configured. `notice` equal to `warning` means no notice band.
- */
-export interface ResolvedPatchFilesTier {
-    notice: number;
-    warning: number;
-    error: number | null;
-}
-/** Line and file-count thresholds governing one patch-size tier. */
-export interface PatchSizeThresholds {
-    /** Line counts at which `large-patch-lines` notice/warning/error issues fire. */
-    lines: ResolvedFileSizeTier;
-    /** File counts at which `large-patch-files` notice/warning/error issues fire. */
-    files: ResolvedPatchFilesTier;
-    /**
-     * The `files.warning` threshold, kept for consumers written before the
-     * files triple existed.
-     */
-    maxFiles: number;
-}
-/**
- * Merges the configured overrides over the defaults for one tier.
- *
- * @param tier - The tier to resolve
- * @param overrides - The `patchLint.patchSizeThresholds` block, if any
- * @returns The effective thresholds
- */
-export declare function resolvePatchSizeThresholds(tier: PatchSizeTierName, overrides: PatchLintPatchSizeThresholds | undefined): PatchSizeThresholds;
-/**
- * True when `file` matches one of the `patchLint.patchSizeRegistrationFiles`
- * globs. A glob without `/` matches the basename, one with `/` the whole
- * engine-relative path. `*` and `?` stay within a segment, `**` crosses
- * segments.
- *
- * @param file - Engine-relative POSIX path
- * @param globs - The configured globs
- */
-export declare function isPatchSizeRegistrationFile(file: string, globs: readonly string[]): boolean;

package/dist/src/core/patch-lint-size-thresholds.js

@@ -1,110 +0,0 @@
-// SPDX-License-Identifier: EUPL-1.2
-/**
- * The patch-size thresholds (`large-patch-lines`, `large-patch-files`) and
- * their merge with `patchLint.patchSizeThresholds`.
- *
- * Its own dependency-free module for the same reason as
- * `patch-lint-file-size.ts`: the config validator checks an override
- * against the merged result, and importing the rule bodies from config
- * parsing would draw an import cycle.
- */
-import { escapeRegex } from '../utils/regex.js';
-/**
- * Built-in line-count bands per tier.
- *
- * Branding patches have a legitimate reason to be large: they include
- * every locale's `brand.ftl`, copied upstream CSS/PNG assets, and the
- * fork-specific `configure.sh` / `brand.properties` under a single
- * `browser/branding/<name>/` subtree. The tier is calibrated against a
- * fresh-fork branding export, which lands around 15-16k lines (localized
- * brand.ftl across many locales + SVG path data + copied upstream CSS).
- * That is the minimum branding diff, so it must surface as a `notice`
- * rather than a `warning`: the warning band sits above it with ~13%
- * headroom, and the error band at roughly 2× the baseline, where
- * non-branding work is probably bundled in.
- *
- * Permissive thresholds are safe because the *gate* into this tier is
- * narrow: auto-detect requires every file under `browser/branding/` plus a
- * tight registration allowlist, or an explicit `PatchMetadata.tier:
- * "branding"` opt-in. A non-branding patch cannot accidentally land here.
- */
-const DEFAULT_PATCH_LINE_THRESHOLDS = {
-    general: { notice: 800, warning: 1500, error: 3000 },
-    test: { notice: 1500, warning: 3000, error: 6000 },
-    branding: { notice: 8000, warning: 18000, error: 30000 },
-};
-/**
- * Built-in `large-patch-files` warning band per tier. There is no notice or
- * error band by default: file count expresses scope, not blast radius.
- *
- * The branding tier sits well above the typical floor because branding
- * patches inherently span many files: PNG/ICO icon assets in 7+ sizes, MSIX
- * manifests, channel-specific configs, locale `.ftl` files, Windows/macOS
- * launcher resources. A fresh-fork branding bundle is around 56 files, so 60
- * leaves headroom for additional channels/locales while still firing on a
- * genuinely bloated patch. The test tier matches general because a
- * test-only patch rarely touches many files.
- */
-const DEFAULT_PATCH_FILES_WARNING = {
-    general: 5,
-    test: 5,
-    branding: 60,
-};
-/**
- * Merges the configured overrides over the defaults for one tier.
- *
- * @param tier - The tier to resolve
- * @param overrides - The `patchLint.patchSizeThresholds` block, if any
- * @returns The effective thresholds
- */
-export function resolvePatchSizeThresholds(tier, overrides) {
-    const configured = overrides?.[tier];
-    const lines = { ...DEFAULT_PATCH_LINE_THRESHOLDS[tier], ...configured?.lines };
-    const files = resolveFilesTier(DEFAULT_PATCH_FILES_WARNING[tier], configured?.files);
-    return { lines, files, maxFiles: files.warning };
-}
-function resolveFilesTier(defaultWarning, configured) {
-    const warning = configured?.warning ?? defaultWarning;
-    return {
-        notice: configured?.notice ?? warning,
-        warning,
-        error: configured?.error ?? null,
-    };
-}
-/**
- * True when `file` matches one of the `patchLint.patchSizeRegistrationFiles`
- * globs. A glob without `/` matches the basename, one with `/` the whole
- * engine-relative path. `*` and `?` stay within a segment, `**` crosses
- * segments.
- *
- * @param file - Engine-relative POSIX path
- * @param globs - The configured globs
- */
-export function isPatchSizeRegistrationFile(file, globs) {
-    if (globs.length === 0)
-        return false;
-    const basename = file.slice(file.lastIndexOf('/') + 1);
-    return globs.some((glob) => globToRegExp(glob).test(glob.includes('/') ? file : basename));
-}
-function globToRegExp(glob) {
-    let source = '';
-    for (let i = 0; i < glob.length; i++) {
-        const char = glob.charAt(i);
-        if (char === '*' && glob.charAt(i + 1) === '*') {
-            // `**/` matches zero or more whole segments, a bare `**` anything.
-            const slash = glob.charAt(i + 2) === '/';
-            source += slash ? '(?:.*/)?' : '.*';
-            i += slash ? 2 : 1;
-        }
-        else if (char === '*') {
-            source += '[^/]*';
-        }
-        else if (char === '?') {
-            source += '[^/]';
-        }
-        else {
-            source += escapeRegex(char);
-        }
-    }
-    return new RegExp(`^${source}$`);
-}