@kingironman2011/license-checker 1.0.1 → 1.1.0

package/dist/output/renderers.js

@@ -0,0 +1,112 @@
+import fs from "node:fs";
+import { detectLicenseTitle } from "../licenses/detect-license-title.js";
+function renderChildren(value, ancestorLastStates) {
+    const keys = Object.keys(value);
+    return keys.flatMap((key, index) => {
+        const child = value[key];
+        const isLast = index === keys.length - 1;
+        const prefix = ancestorLastStates
+            .map((wasLast) => (wasLast ? "   " : "│  "))
+            .join("");
+        const isContainer = child !== null && typeof child === "object";
+        const line = `${prefix}${isLast ? "└" : "├"}─ ${key}${isContainer ? "" : `: ${String(child)}`}`;
+        return [
+            line,
+            ...(isContainer
+                ? renderChildren(child, [
+                    ...ancestorLastStates,
+                    isLast,
+                ])
+                : []),
+        ];
+    });
+}
+function asTreeObject(value) {
+    const lines = renderChildren(value, []);
+    return lines.length ? `${lines.join("\n")}\n` : "";
+}
+export const asTree = (sorted) => asTreeObject(sorted);
+export const asSummary = (sorted) => {
+    const licenseCountMap = new global.Map();
+    const licenseCountArray = [];
+    const sortedLicenseCountObj = {};
+    Object.values(sorted).forEach(({ licenses }) => {
+        if (typeof licenses === "string") {
+            licenseCountMap.set(licenses, (licenseCountMap.get(licenses) ?? 0) + 1);
+        }
+    });
+    licenseCountMap.forEach((count, license) => {
+        licenseCountArray.push({ license, count });
+    });
+    licenseCountArray
+        .toSorted((a, b) => b.count - a.count)
+        .forEach(({ license, count }) => {
+        sortedLicenseCountObj[license] = String(count);
+    });
+    return asTreeObject(sortedLicenseCountObj);
+};
+/**
+ * Exports data as Markdown (*.md) which has its own syntax.
+ *
+ * @param  sorted                  The sorted JSON data from all packages.
+ * @param  {object} [customFormat] The custom format with information about the needed keys.
+ * @return {string}                The returning plain text.
+ */
+export const asMarkDown = (sorted, customFormat) => {
+    const text = [];
+    if (customFormat && Object.keys(customFormat).length > 0) {
+        Object.keys(sorted).forEach((sortedItem) => {
+            text.push(`- **[${sortedItem}](${sorted[sortedItem].repository})**`);
+            Object.keys(customFormat).forEach((customItem) => {
+                text.push(`    - ${customItem}: ${sorted[sortedItem][customItem]}`);
+            });
+        });
+    }
+    else {
+        Object.keys(sorted).forEach((key) => {
+            const module = sorted[key];
+            text.push(`- [${key}](${module.repository}) - ${module.licenses}`);
+        });
+    }
+    return text.join("\n");
+};
+const getModuleNameForLicenseTextHeader = (moduleName = "") => {
+    const lastIndexOfAtCharacter = moduleName.lastIndexOf("@");
+    return `${moduleName.substring(0, lastIndexOfAtCharacter)} ${moduleName.substring(lastIndexOfAtCharacter + 1)}\n`;
+};
+/**
+ * Output data in plain vertical format like Angular CLI does: https://angular.io/3rdpartylicenses.txt
+ */
+export const asPlainVertical = (sorted) => Object.entries(sorted)
+    .map(([moduleName, moduleData]) => {
+    let licenseText = getModuleNameForLicenseTextHeader(moduleName);
+    if (Array.isArray(moduleData.licenses) &&
+        moduleData.licenses.length > 0) {
+        // biome-ignore lint/suspicious/useIterableCallbackReturn: TODO we'll have to check if "moduleData.licenses" can contain something that might not be handled inside the map callback
+        licenseText += moduleData.licenses.map((moduleLicense) => {
+            if (typeof moduleLicense === "object") {
+                return moduleLicense.type || moduleLicense.name;
+            }
+            if (typeof moduleLicense === "string") {
+                return moduleLicense;
+            }
+        });
+    }
+    else if (!Array.isArray(moduleData.licenses) &&
+        moduleData.licenses !== undefined &&
+        typeof moduleData.licenses === "object" &&
+        (moduleData.licenses.type || moduleData.licenses.name)) {
+        licenseText += detectLicenseTitle(moduleData.licenses.type || moduleData.licenses.name);
+    }
+    else if (typeof moduleData.licenses === "string") {
+        licenseText += detectLicenseTitle(moduleData.licenses);
+    }
+    licenseText += "\n";
+    if (typeof moduleData.licenseFile === "string") {
+        licenseText += fs.readFileSync(moduleData.licenseFile, {
+            encoding: "utf8",
+        });
+    }
+    return licenseText;
+})
+    .join("\n\n");

package/dist/output/write-output.d.ts

@@ -1,2 +1,3 @@
-import type { DependencyLicense } from "../types.js";
-export declare function writeIndividualLicenseFilesToDir(outputDir: string, items: DependencyLicense[]): Promise<void>;
+import type { ModuleInfos } from "../types.js";
+export declare function writeOutputToFile(outputFile: string, formattedOutput: string): Promise<void>;
+export declare function writeIndividualLicenseFilesToDir(outDir: string, resultJson: ModuleInfos): Promise<void>;

package/dist/output/write-output.js

@@ -1,15 +1,23 @@
-import { cp, mkdir, writeFile } from "node:fs/promises";
+import fs from "node:fs";
 import path from "node:path";
-export async function writeIndividualLicenseFilesToDir(outputDir, items) {
-    for (const item of items) {
-        const safeName = item.name.replaceAll("/", "+");
-        const destination = path.join(outputDir, item.scope, `${safeName}@${item.version}`);
-        await mkdir(destination, { recursive: true });
-        for (const file of item.licenseFiles) {
-            await cp(path.join(item.packagePath, file), path.join(destination, file));
+export async function writeOutputToFile(outputFile, formattedOutput) {
+    const dir = path.dirname(outputFile);
+    await fs.promises.mkdir(dir, { recursive: true });
+    await fs.promises.writeFile(outputFile, formattedOutput, "utf-8");
+}
+export async function writeIndividualLicenseFilesToDir(outDir, resultJson) {
+    await fs.promises.mkdir(outDir, { recursive: true });
+    for (const key of Object.keys(resultJson)) {
+        const { licenseFile } = resultJson[key];
+        if (licenseFile && fs.existsSync(licenseFile)) {
+            const outPath = path.join(outDir, `${key}-LICENSE.txt`);
+            // key contains versioned packages, potentially scoped, e.g. @foo/bar@1.2.3
+            const effectiveOutDir = path.dirname(outPath);
+            await fs.promises.mkdir(effectiveOutDir, { recursive: true });
+            await fs.promises.copyFile(licenseFile, outPath);
         }
-        if (item.licenseFiles.length === 0) {
-            await writeFile(path.join(destination, "LICENSE-INFO.txt"), `License metadata: ${item.license}\n`);
+        else {
+            console.warn(`No license file found for module '${key}'`);
         }
     }
 }

package/dist/policies/license-policy.d.ts

@@ -0,0 +1,20 @@
+import type { LicenseCheckOptions, LicenseValue } from "../types.js";
+export declare function getLicensePolicy(options: Pick<LicenseCheckOptions, "failOn" | "onlyAllow">): {
+    failOnLicenses: string[];
+    onlyAllowLicenses: string[];
+};
+export declare function checkForFailOn(currentLicense: LicenseValue | LicenseValue[], failOnLicenses: string[]): void;
+/**
+ * Check if the current license contains (eventually among others) at least one of the allowed licenses.
+ */
+export declare function checkForOnlyAllow(currentLicense: LicenseValue | LicenseValue[], packageName: string, onlyAllowLicenses: string[]): void;
+export declare function throwIfLicensePolicyFails({ currentLicense, failOnLicenses, onlyAllowLicenses, packageName, }: {
+    currentLicense?: LicenseValue | LicenseValue[];
+    failOnLicenses: string[];
+    onlyAllowLicenses: string[];
+    packageName: string;
+}): void;
+export declare function getLicenseMatch(licensesArr: LicenseValue[], compareLicenses: string[]): {
+    hasUnknownLicense: boolean;
+    match: boolean;
+};

package/dist/policies/license-policy.js

@@ -0,0 +1,112 @@
+import { correctSpdxExpression, spdxExpressionSatisfies, } from "../licenses/spdx.js";
+const LICENSE_TITLE_UNKNOWN = "UNKNOWN";
+const bsdLicenses = ["0BSD", "BSD-2-Clause", "BSD-3-Clause", "BSD-4-Clause"];
+const transformBSD = (spdx) => spdx === "BSD" ? `(${bsdLicenses.join(" OR ")})` : spdx;
+const expandBSD = (spdx) => spdx === "BSD" ? bsdLicenses : [spdx];
+const invertResultOf = (fn) => (spdx) => !fn(spdx);
+const spdxIsValid = (spdx) => correctSpdxExpression(spdx) === spdx;
+const parsePolicyList = (value) => {
+    const licenses = [];
+    value.split(";").forEach((license) => {
+        const trimmed = license.trim();
+        if (trimmed.length > 0) {
+            licenses.push(trimmed);
+        }
+    });
+    return licenses;
+};
+export function getLicensePolicy(options) {
+    if (options.failOn) {
+        return {
+            failOnLicenses: parsePolicyList(options.failOn),
+            onlyAllowLicenses: [],
+        };
+    }
+    if (options.onlyAllow) {
+        return {
+            failOnLicenses: [],
+            onlyAllowLicenses: parsePolicyList(options.onlyAllow),
+        };
+    }
+    return {
+        failOnLicenses: [],
+        onlyAllowLicenses: [],
+    };
+}
+export function checkForFailOn(currentLicense, failOnLicenses) {
+    if (!Array.isArray(failOnLicenses) || failOnLicenses.length === 0) {
+        return;
+    }
+    const licenses = Array.isArray(currentLicense)
+        ? currentLicense
+        : [currentLicense];
+    if (licenses.some((license) => typeof license === "string" && failOnLicenses.includes(license))) {
+        throw new Error(`Found license defined by the --failOn flag: "${currentLicense}". Exiting.`);
+    }
+}
+/**
+ * Check if the current license contains (eventually among others) at least one of the allowed licenses.
+ */
+export function checkForOnlyAllow(currentLicense, packageName, onlyAllowLicenses) {
+    if (onlyAllowLicenses.length > 0) {
+        let containsOneOfAllowedPackages = false;
+        for (const allowedLicense of onlyAllowLicenses) {
+            // "currentLicense" is a longer string that may contain several license names,
+            // and we check if one of those is a license listed in the "onlyAllowLicenses"
+            // licenses array:
+            if ((typeof currentLicense === "string" &&
+                currentLicense.includes(allowedLicense)) ||
+                (Array.isArray(currentLicense) &&
+                    currentLicense.includes(allowedLicense)) ||
+                (typeof currentLicense === "object" &&
+                    currentLicense !== null &&
+                    !Array.isArray(currentLicense) &&
+                    (currentLicense.type === allowedLicense ||
+                        currentLicense.name === allowedLicense))) {
+                containsOneOfAllowedPackages = true;
+                break;
+            }
+        }
+        if (!containsOneOfAllowedPackages) {
+            throw new Error(`Package "${packageName}" is licensed under "${currentLicense}" which is not permitted by the --onlyAllow flag. Exiting.`);
+        }
+    }
+}
+export function throwIfLicensePolicyFails({ currentLicense, failOnLicenses, onlyAllowLicenses, packageName, }) {
+    if (currentLicense) {
+        checkForFailOn(currentLicense, failOnLicenses);
+        checkForOnlyAllow(currentLicense, packageName, onlyAllowLicenses);
+    }
+}
+export function getLicenseMatch(licensesArr, compareLicenses) {
+    const expandedCompareLicenses = compareLicenses.flatMap(expandBSD);
+    const validSPDXLicenses = expandedCompareLicenses.filter(spdxIsValid);
+    const invalidSPDXLicenses = expandedCompareLicenses
+        .map(transformBSD)
+        .filter(invertResultOf(spdxIsValid));
+    let hasUnknownLicense = false;
+    let match = false;
+    licensesArr.forEach((licenseValue) => {
+        const license = typeof licenseValue === "string"
+            ? licenseValue
+            : (licenseValue.type ?? licenseValue.name ?? "");
+        if (license.indexOf(LICENSE_TITLE_UNKNOWN) >= 0) {
+            // Necessary due to colorization and preserves the historic include/exclude behavior for unknown licenses.
+            hasUnknownLicense = true;
+        }
+        else {
+            const withoutTrailingAsterisk = license.endsWith("*")
+                ? license.slice(0, -1)
+                : license;
+            const transformed = transformBSD(withoutTrailingAsterisk);
+            const correctedSpdx = correctSpdxExpression(transformed);
+            if (invalidSPDXLicenses.indexOf(transformed) >= 0 ||
+                (correctedSpdx &&
+                    validSPDXLicenses.length > 0 &&
+                    spdxExpressionSatisfies(correctedSpdx, validSPDXLicenses))) {
+                match = true;
+            }
+        }
+    });
+    return { hasUnknownLicense, match };
+}

package/dist/policies/package-filters.d.ts

@@ -0,0 +1,6 @@
+import type { ModuleInfos } from "../types.js";
+export declare const getOptionArray: (option: string | string[] | undefined) => string[] | false;
+export declare const includePackages: (whitelist: string[], packages: ModuleInfos) => ModuleInfos;
+export declare const excludePackages: (blacklist: string[], packages: ModuleInfos) => ModuleInfos;
+export declare const excludePackagesStartingWith: (blacklist: string[], packages: ModuleInfos) => ModuleInfos;
+export declare const excludePrivatePackages: (packages: ModuleInfos) => ModuleInfos;

package/dist/policies/package-filters.js

@@ -0,0 +1,56 @@
+export const getOptionArray = (option) => {
+    if (Array.isArray(option)) {
+        return option;
+    }
+    if (typeof option === "string") {
+        return option.split(";");
+    }
+    return false;
+};
+const matchesPackageSelector = (packageName, selector) => packageName.startsWith(selector.lastIndexOf("@") > 0 ? selector : `${selector}@`);
+export const includePackages = (whitelist, packages) => {
+    const resultJson = {};
+    Object.keys(packages).forEach((packageName) => {
+        // Whitelist packages by declaring:
+        // 1. the package full name. Ex: `react` (we suffix an '@' to ensure we don't match packages like `react-native`)
+        // 2. the package full name and the major version. Ex: `react@16`
+        // 3. the package full name and full version. Ex: `react@16.0.2`
+        if (whitelist.findIndex((whitelistPackage) => matchesPackageSelector(packageName, whitelistPackage)) !== -1) {
+            resultJson[packageName] = packages[packageName];
+        }
+    });
+    return resultJson;
+};
+export const excludePackages = (blacklist, packages) => {
+    const resultJson = {};
+    Object.keys(packages).forEach((packageName) => {
+        // Blacklist packages by declaring:
+        // 1. the package full name. Ex: `react` (we suffix an '@' to ensure we don't match packages like `react-native`)
+        // 2. the package full name and the major version. Ex: `react@16`
+        // 3. the package full name and full version. Ex: `react@16.0.2`
+        if (blacklist.findIndex((blacklistPackage) => matchesPackageSelector(packageName, blacklistPackage)) === -1) {
+            resultJson[packageName] = packages[packageName];
+        }
+    });
+    return resultJson;
+};
+export const excludePackagesStartingWith = (blacklist, packages) => {
+    const resultJson = { ...packages };
+    for (const packageName in resultJson) {
+        for (const denyPrefix of blacklist) {
+            if (packageName.startsWith(denyPrefix)) {
+                delete resultJson[packageName];
+            }
+        }
+    }
+    return resultJson;
+};
+export const excludePrivatePackages = (packages) => {
+    const resultJson = { ...packages };
+    Object.keys(resultJson).forEach((packageName) => {
+        if (resultJson[packageName]?.private) {
+            delete resultJson[packageName];
+        }
+    });
+    return resultJson;
+};

package/dist/shared/debug.d.ts

@@ -0,0 +1 @@
+export declare function createDebugLogger(namespace: string, output?: (...args: unknown[]) => void): (...args: unknown[]) => void;

package/dist/shared/debug.js

@@ -0,0 +1,25 @@
+import { format } from "node:util";
+function namespaceMatches(pattern, namespace) {
+    const expression = new RegExp(`^${pattern.split("*").map(escapeRegExp).join(".*?")}$`);
+    return expression.test(namespace);
+}
+function escapeRegExp(value) {
+    return value.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function isEnabled(namespace) {
+    const patterns = (process.env.DEBUG ?? "").split(/[\s,]+/).filter(Boolean);
+    let enabled = false;
+    for (const pattern of patterns) {
+        const excluded = pattern.startsWith("-");
+        if (namespaceMatches(excluded ? pattern.slice(1) : pattern, namespace)) {
+            enabled = !excluded;
+        }
+    }
+    return enabled;
+}
+export function createDebugLogger(namespace, output = console.error) {
+    return (...args) => {
+        if (isEnabled(namespace))
+            output(`${namespace} ${format(...args)}`);
+    };
+}

package/dist/shared/first-defined.d.ts

@@ -0,0 +1 @@
+export declare function firstDefined<T>(...values: Array<T | undefined>): T | undefined;

package/dist/shared/first-defined.js

@@ -0,0 +1,7 @@
+export function firstDefined(...values) {
+    for (const value of values) {
+        if (typeof value !== "undefined") {
+            return value;
+        }
+    }
+}

package/dist/shared/semver.d.ts

@@ -0,0 +1 @@
+export declare function semverSatisfies(versionString: string, range: string): boolean;

package/dist/shared/semver.js

@@ -0,0 +1,269 @@
+const FULL_VERSION = /^=?v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\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-]+)*)?$/;
+const NUMERIC_IDENTIFIER = /^(0|[1-9]\d*)$/;
+function parsePrerelease(value) {
+    if (!value)
+        return [];
+    return value.split(".").map((identifier) => identifier);
+}
+function parseVersion(value) {
+    const match = FULL_VERSION.exec(value);
+    if (!match)
+        return null;
+    return {
+        major: match[1],
+        minor: match[2],
+        patch: match[3],
+        prerelease: parsePrerelease(match[4]),
+    };
+}
+function compareNumeric(left, right) {
+    if (left.length !== right.length)
+        return left.length < right.length ? -1 : 1;
+    return left === right ? 0 : left < right ? -1 : 1;
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 || right.length === 0) {
+        return left.length === right.length ? 0 : left.length === 0 ? 1 : -1;
+    }
+    const length = Math.min(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === rightPart)
+            continue;
+        const leftNumeric = NUMERIC_IDENTIFIER.test(leftPart);
+        const rightNumeric = NUMERIC_IDENTIFIER.test(rightPart);
+        if (leftNumeric && !rightNumeric)
+            return -1;
+        if (!leftNumeric && rightNumeric)
+            return 1;
+        if (leftNumeric && rightNumeric)
+            return compareNumeric(leftPart, rightPart);
+        return String(leftPart) < String(rightPart) ? -1 : 1;
+    }
+    return left.length === right.length ? 0 : left.length < right.length ? -1 : 1;
+}
+function compareVersions(left, right) {
+    for (const component of ["major", "minor", "patch"]) {
+        const compared = compareNumeric(left[component], right[component]);
+        if (compared !== 0)
+            return compared;
+    }
+    return comparePrerelease(left.prerelease, right.prerelease);
+}
+function parsePartialVersion(source) {
+    const value = source.replace(/^=?v?/, "");
+    const [withoutBuild] = value.split("+");
+    const hyphenIndex = withoutBuild.indexOf("-");
+    const core = hyphenIndex < 0 ? withoutBuild : withoutBuild.slice(0, hyphenIndex);
+    const prereleaseText = hyphenIndex < 0 ? undefined : withoutBuild.slice(hyphenIndex + 1);
+    const parts = core.split(".");
+    if (parts.length > 3 || parts.some((part) => part.length === 0)) {
+        throw new Error(`Invalid semantic version range token: ${source}`);
+    }
+    const values = [];
+    let wildcardSeen = false;
+    for (const part of parts) {
+        if (/^(?:x|\*)$/i.test(part)) {
+            wildcardSeen = true;
+            values.push(null);
+        }
+        else if (/^(?:0|[1-9]\d*)$/.test(part) && !wildcardSeen) {
+            values.push(part);
+        }
+        else {
+            throw new Error(`Invalid semantic version range token: ${source}`);
+        }
+    }
+    if (wildcardSeen && prereleaseText !== undefined) {
+        throw new Error(`A wildcard range cannot include a prerelease: ${source}`);
+    }
+    if (prereleaseText !== undefined &&
+        values.filter((part) => part !== null).length !== 3) {
+        throw new Error(`A prerelease requires a complete version: ${source}`);
+    }
+    const specified = values.filter((part) => part !== null).length;
+    if (specified !== values.length) {
+        for (let index = values.findIndex((part) => part === null); index < values.length; index += 1) {
+            if (values[index] !== null) {
+                throw new Error(`Invalid numeric component after wildcard: ${source}`);
+            }
+        }
+    }
+    const prerelease = prereleaseText === undefined ? [] : parsePrerelease(prereleaseText);
+    if (prereleaseText !== undefined && prerelease.length === 0) {
+        throw new Error(`Invalid prerelease in semantic version range: ${source}`);
+    }
+    return {
+        major: values["0"] ?? null,
+        minor: values[1] ?? null,
+        patch: values[2] ?? null,
+        prerelease,
+        specified,
+        wildcard: specified < 3,
+    };
+}
+function makeVersion(major, minor = "0", patch = "0", prerelease = []) {
+    return { major, minor, patch, prerelease };
+}
+function increment(value) {
+    return (BigInt(value) + 1n).toString();
+}
+function lowerBound(partial) {
+    if (partial.major === null)
+        return null;
+    return makeVersion(partial.major, partial.minor ?? "0", partial.patch ?? "0", partial.prerelease);
+}
+function upperBound(partial) {
+    if (partial.major === null)
+        return null;
+    if (partial.minor === null)
+        return makeVersion(increment(partial.major), "0", "0", ["0"]);
+    if (partial.patch === null) {
+        return makeVersion(partial.major, increment(partial.minor), "0", ["0"]);
+    }
+    return makeVersion(partial.major, partial.minor, increment(partial.patch), [
+        "0",
+    ]);
+}
+function comparator(operator, version) {
+    return version ? [{ operator, version }] : [];
+}
+function expandPartial(partial, operator) {
+    const lower = lowerBound(partial);
+    const upper = upperBound(partial);
+    if (operator === "^" || operator === "~" || operator === "~>") {
+        if (!lower)
+            return [];
+        let ceiling;
+        if (operator === "~" || operator === "~>") {
+            ceiling =
+                partial.minor === null
+                    ? makeVersion(increment(partial.major), "0", "0", ["0"])
+                    : makeVersion(partial.major, increment(partial.minor), "0", ["0"]);
+        }
+        else if (partial.major !== "0") {
+            ceiling = makeVersion(increment(partial.major), "0", "0", [
+                "0",
+            ]);
+        }
+        else if (partial.minor === null) {
+            ceiling = makeVersion("1", "0", "0", ["0"]);
+        }
+        else if (partial.minor !== "0") {
+            ceiling = makeVersion("0", increment(partial.minor), "0", ["0"]);
+        }
+        else if (partial.patch === null) {
+            ceiling = makeVersion("0", "1", "0", ["0"]);
+        }
+        else {
+            ceiling = makeVersion("0", "0", increment(partial.patch), ["0"]);
+        }
+        return [...comparator(">=", lower), ...comparator("<", ceiling)];
+    }
+    if (!lower) {
+        if (operator === "" ||
+            operator === "=" ||
+            operator === ">=" ||
+            operator === "<=")
+            return [];
+        throw new Error(`Invalid wildcard range operator: ${operator}`);
+    }
+    if (operator === "" || operator === "=") {
+        if (!partial.wildcard)
+            return comparator("=", lower);
+        return [...comparator(">=", lower), ...comparator("<", upper)];
+    }
+    if (!partial.wildcard) {
+        return comparator(operator, lower);
+    }
+    switch (operator) {
+        case ">=":
+            return comparator(">=", lower);
+        case ">":
+            return comparator(">=", upper);
+        case "<":
+            return comparator("<", lower);
+        case "<=":
+            return comparator("<", upper);
+        default:
+            throw new Error(`Invalid semantic version range operator: ${operator}`);
+    }
+}
+function tokenizeComparators(range) {
+    const result = [];
+    let offset = 0;
+    while (offset < range.length) {
+        while (/\s/.test(range[offset] ?? ""))
+            offset += 1;
+        if (offset >= range.length)
+            break;
+        const operatorMatch = /^(~>|<=|>=|<|>|=|~|\^)/.exec(range.slice(offset));
+        const operator = operatorMatch?.[0] ?? "";
+        offset += operator.length;
+        while (/\s/.test(range[offset] ?? ""))
+            offset += 1;
+        const start = offset;
+        while (offset < range.length && !/\s/.test(range[offset] ?? ""))
+            offset += 1;
+        if (start === offset)
+            throw new Error("Missing version after range operator");
+        result.push({ operator, version: range.slice(start, offset) });
+    }
+    return result;
+}
+function expandHyphenRange(leftSource, rightSource) {
+    const left = parsePartialVersion(leftSource);
+    const right = parsePartialVersion(rightSource);
+    return [
+        ...comparator(">=", lowerBound(left)),
+        ...(right.wildcard
+            ? comparator("<", upperBound(right))
+            : comparator("<=", lowerBound(right))),
+    ];
+}
+function expandComparatorSet(source) {
+    const hyphen = /^(\S+)\s+-\s+(\S+)$/.exec(source.trim());
+    if (hyphen)
+        return expandHyphenRange(hyphen[1], hyphen[2]);
+    return tokenizeComparators(source).flatMap(({ operator, version }) => expandPartial(parsePartialVersion(version), operator));
+}
+function comparatorMatches(version, test) {
+    const compared = compareVersions(version, test.version);
+    switch (test.operator) {
+        case "=":
+            return compared === 0;
+        case ">":
+            return compared > 0;
+        case ">=":
+            return compared >= 0;
+        case "<":
+            return compared < 0;
+        case "<=":
+            return compared <= 0;
+    }
+}
+function prereleaseAllowed(version, comparators) {
+    if (version.prerelease.length === 0)
+        return true;
+    return comparators.some(({ version: comparatorVersion }) => comparatorVersion.prerelease.length > 0 &&
+        comparatorVersion.major === version.major &&
+        comparatorVersion.minor === version.minor &&
+        comparatorVersion.patch === version.patch);
+}
+export function semverSatisfies(versionString, range) {
+    const version = parseVersion(versionString);
+    if (!version)
+        return false;
+    const alternatives = range.split("||");
+    if (alternatives.some((alternative) => alternative.trim() === "")) {
+        if (alternatives.length === 1)
+            return true;
+        throw new Error(`Invalid semantic version range: ${range}`);
+    }
+    return alternatives.some((alternative) => {
+        const comparators = expandComparatorSet(alternative);
+        return (prereleaseAllowed(version, comparators) &&
+            comparators.every((test) => comparatorMatches(version, test)));
+    });
+}