@kingironman2011/license-checker 1.0.1 → 1.1.0

package/dist/licenses/collect-license-results.js

@@ -1,12 +1,321 @@
-import { readdir } from "node:fs/promises";
-export async function collectLicenseResults(packages) {
-    for (const item of packages) {
-        const entries = await readdir(item.packagePath, { withFileTypes: true });
-        item.licenseFiles = entries
-            .filter((entry) => entry.isFile() &&
-            /^(license|licence|copying|notice)(\.|$)/i.test(entry.name))
-            .map((entry) => entry.name)
-            .toSorted((a, b) => a.localeCompare(b));
-    }
-    return packages.toSorted((a, b) => a.name.localeCompare(b.name) || a.version.localeCompare(b.version));
-}
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { walkDependencyTree } from "../dependencies/walk-dependency-tree.js";
+import { firstDefined } from "../shared/first-defined.js";
+import { semverSatisfies } from "../shared/semver.js";
+import { getCopyrightLines } from "./copyright.js";
+import { detectLicenseTitle } from "./detect-license-title.js";
+import { findLicenseFiles } from "./find-license-files.js";
+import { getAuthorDetails, getRepositoryUrl, storeReadmeInPackageJsonIfExists, } from "./package-metadata.js";
+const LICENSE_TITLE_UNKNOWN = "UNKNOWN";
+const INITIAL_MODULE_INFO = { licenses: LICENSE_TITLE_UNKNOWN };
+const getPackageNameAndVersion = (packageJson) => `${packageJson.name}@${packageJson.version}`;
+const findClarification = (clarifications, packageJson) => {
+    const packageName = packageJson.name;
+    const version = packageJson.version;
+    if (!packageName || !version)
+        return undefined;
+    return clarifications[packageName]?.find((clarification) => version === clarification.semverRange ||
+        semverSatisfies(version, clarification.semverRange));
+};
+const shouldSkipPackage = ({ packageJson, data, options, }) => Boolean(data[getPackageNameAndVersion(packageJson)] ||
+    (options.production && packageJson.extraneous) ||
+    (options.development && !packageJson.extraneous && !packageJson.root));
+const collectPackageLicenseInfo = ({ packageJson: currentExtendedPackageJson, data, options, }) => {
+    const moduleInfo = { ...INITIAL_MODULE_INFO };
+    const currentPackageNameAndVersion = getPackageNameAndVersion(currentExtendedPackageJson);
+    let licenseFilesInCurrentModuleDirectory = [];
+    let licenseData;
+    let licenseFile;
+    let noticeFiles = [];
+    const clarification = findClarification(options.clarifications, currentExtendedPackageJson);
+    let passedClarificationCheck = !clarification?.checksum;
+    if (clarification) {
+        clarification.used = true;
+    }
+    if (shouldSkipPackage({
+        packageJson: currentExtendedPackageJson,
+        data,
+        options,
+    })) {
+        return false;
+    }
+    if (currentExtendedPackageJson.private) {
+        moduleInfo.private = true;
+    }
+    data[currentPackageNameAndVersion] = moduleInfo;
+    // Include property in output unless custom format has set property explicitly to false:
+    const mustInclude = (propertyName = "") => options?.customFormat?.[propertyName] !== false;
+    if (mustInclude("repository")) {
+        const repositoryUrl = getRepositoryUrl({
+            clarificationRepository: clarification?.repository,
+            jsonRepository: currentExtendedPackageJson?.repository,
+        });
+        if (repositoryUrl) {
+            moduleInfo.repository = repositoryUrl;
+        }
+    }
+    if (mustInclude("url")) {
+        // TODO: Figure out where the check for currentExtendedPackageJson.url.web comes from. It's in the original license-checker,
+        //       but I can't find any documentation on it.
+        const url = firstDefined(clarification?.url, typeof currentExtendedPackageJson?.url === "object"
+            ? currentExtendedPackageJson.url.web
+            : undefined);
+        if (url) {
+            moduleInfo.url = url;
+        }
+    }
+    if (typeof currentExtendedPackageJson.author === "object") {
+        const { publisher, email, url } = getAuthorDetails({
+            clarification,
+            author: currentExtendedPackageJson?.author,
+        });
+        if (mustInclude("publisher") && publisher) {
+            moduleInfo.publisher = publisher;
+        }
+        if (mustInclude("email") && email) {
+            moduleInfo.email = email;
+        }
+        // moduleInfo.url can for some reason already be set to currentExtendedPackageJson.url.web further up in the code,
+        // so we only set it if it's not already set.
+        if (typeof moduleInfo.url !== "undefined" && mustInclude("url") && url) {
+            moduleInfo.url = url;
+        }
+    }
+    if (options.unknown) {
+        moduleInfo.dependencyPath = currentExtendedPackageJson.path;
+    }
+    const modulePath = firstDefined(clarification?.path, currentExtendedPackageJson?.path);
+    if (mustInclude("path") && typeof modulePath === "string") {
+        moduleInfo.path = modulePath;
+    }
+    // Eventually store the contents of the module's README.md in currentExtendedPackageJson.readme:
+    storeReadmeInPackageJsonIfExists(modulePath, currentExtendedPackageJson);
+    // Try to get the license information from the clarification file or from the package.json file:
+    licenseData =
+        clarification?.licenses ??
+            currentExtendedPackageJson.license ??
+            currentExtendedPackageJson.licenses;
+    if (licenseData) {
+        // License information has been collected from either the clarification file or from the package.json file
+        if (Array.isArray(licenseData) && licenseData.length > 0) {
+            // biome-ignore lint/suspicious/useIterableCallbackReturn: TODO we'll have to check if "licenseData" can contain something that might not be handled inside the map callback
+            moduleInfo.licenses = licenseData
+                .map((moduleLicense) => {
+                const moduleLicenseTypeOrName = typeof moduleLicense === "string"
+                    ? moduleLicense
+                    : firstDefined(moduleLicense.type, moduleLicense.name);
+                if (typeof moduleLicenseTypeOrName === "string") {
+                    return moduleLicenseTypeOrName;
+                }
+                if (typeof moduleLicense === "string") {
+                    return moduleLicense;
+                }
+            })
+                .filter((license) => typeof license === "string");
+        }
+        else if (!Array.isArray(licenseData) && typeof licenseData === "object") {
+            const licenseTitle = detectLicenseTitle(firstDefined(licenseData.type, licenseData.name));
+            if (licenseTitle)
+                moduleInfo.licenses = licenseTitle;
+        }
+        else if (typeof licenseData === "string") {
+            const licenseTitle = detectLicenseTitle(licenseData);
+            if (licenseTitle)
+                moduleInfo.licenses = licenseTitle;
+        }
+    }
+    else if (detectLicenseTitle(currentExtendedPackageJson.readme)) {
+        // Try to get the license information from the README file if neither the clarification file nor the package.json
+        // file contained any license information:
+        const licenseTitle = detectLicenseTitle(currentExtendedPackageJson.readme);
+        if (licenseTitle)
+            moduleInfo.licenses = licenseTitle;
+    }
+    if (Array.isArray(moduleInfo.licenses)) {
+        if (moduleInfo.licenses.length === 1) {
+            moduleInfo.licenses = moduleInfo.licenses[0];
+        }
+    }
+    if (clarification?.licenseFile) {
+        licenseFilesInCurrentModuleDirectory = [clarification.licenseFile];
+    }
+    else if (modulePath && fs.existsSync(modulePath)) {
+        const filesInModuleDirectory = fs.readdirSync(modulePath);
+        licenseFilesInCurrentModuleDirectory = findLicenseFiles(filesInModuleDirectory);
+        noticeFiles = filesInModuleDirectory.filter((filename) => {
+            const uppercased = filename.toUpperCase();
+            const name = path
+                .basename(uppercased)
+                .replace(path.extname(uppercased), "");
+            return name === "NOTICE";
+        });
+    }
+    licenseFilesInCurrentModuleDirectory.forEach(function findBetterLicenseData(filename, index) {
+        if (!modulePath)
+            return;
+        licenseFile = path.join(modulePath, filename);
+        // Checking that the file is in fact a normal file and not a directory for example.
+        if (fs.lstatSync(licenseFile).isFile()) {
+            let currentLicenceFilesContent;
+            if (!moduleInfo.licenses ||
+                (Array.isArray(moduleInfo.licenses)
+                    ? moduleInfo.licenses.some((license) => license === LICENSE_TITLE_UNKNOWN)
+                    : typeof moduleInfo.licenses === "string" &&
+                        moduleInfo.licenses.indexOf(LICENSE_TITLE_UNKNOWN) > -1)
+            // TODO: Should we override a custom license?
+            // || moduleInfo.licenses.indexOf('Custom:') === 0
+            ) {
+                //Only re-check the license if we didn't get it from elsewhere
+                currentLicenceFilesContent = fs.readFileSync(licenseFile, {
+                    encoding: "utf8",
+                });
+                const licenseTitle = detectLicenseTitle(currentLicenceFilesContent);
+                if (licenseTitle)
+                    moduleInfo.licenses = licenseTitle;
+            }
+            if (index === 0) {
+                // Treat the file with the highest precedence as licenseFile
+                if (clarification !== undefined && !passedClarificationCheck) {
+                    if (!currentLicenceFilesContent) {
+                        currentLicenceFilesContent = fs.readFileSync(licenseFile, {
+                            encoding: "utf8",
+                        });
+                    }
+                    const sha256 = createHash("sha256")
+                        .update(currentLicenceFilesContent)
+                        .digest("hex");
+                    if (clarification.checksum !== sha256) {
+                        throw new Error(`Clarification checksum mismatch for ${currentPackageNameAndVersion} :(\nFile checked: ${licenseFile}`);
+                    }
+                    passedClarificationCheck = true;
+                }
+                if (mustInclude("licenseFile")) {
+                    moduleInfo.licenseFile = firstDefined(clarification?.licenseFile, options.basePath
+                        ? path.relative(options.basePath, licenseFile)
+                        : licenseFile);
+                }
+                if (mustInclude("licenseText") && options.customFormat) {
+                    if (clarification?.licenseText) {
+                        moduleInfo.licenseText = clarification.licenseText;
+                    }
+                    else {
+                        if (!currentLicenceFilesContent) {
+                            currentLicenceFilesContent = fs.readFileSync(licenseFile, {
+                                encoding: "utf8",
+                            });
+                        }
+                        if (options.args && !options.args.csv) {
+                            moduleInfo.licenseText = currentLicenceFilesContent.trim();
+                        }
+                        else {
+                            moduleInfo.licenseText = currentLicenceFilesContent
+                                .replace(/"/g, "'")
+                                .replace(/\r?\n|\r/g, " ")
+                                .trim();
+                        }
+                    }
+                    if (clarification?.licenseStart) {
+                        const startIndex = moduleInfo.licenseText.indexOf(clarification.licenseStart);
+                        let endIndex;
+                        if (clarification?.licenseEnd) {
+                            endIndex = moduleInfo.licenseText.indexOf(clarification.licenseEnd, startIndex);
+                        }
+                        else {
+                            endIndex = moduleInfo.licenseText.length;
+                        }
+                        moduleInfo.licenseText = moduleInfo.licenseText.substring(startIndex, endIndex);
+                    }
+                }
+                if (mustInclude("copyright") && options.customFormat) {
+                    if (clarification?.copyright) {
+                        moduleInfo.copyright = clarification.copyright;
+                    }
+                    else {
+                        if (!currentLicenceFilesContent) {
+                            currentLicenceFilesContent = fs.readFileSync(licenseFile, {
+                                encoding: "utf8",
+                            });
+                        }
+                        const linesWithCopyright = getCopyrightLines(currentLicenceFilesContent);
+                        if (linesWithCopyright.length > 0) {
+                            moduleInfo.copyright = linesWithCopyright[0]
+                                .replace(/\n/g, ". ")
+                                .trim();
+                        }
+                        // Mark files with multiple copyright statements. This might be
+                        // an indicator to take a closer look at the LICENSE file.
+                        if (linesWithCopyright.length > 1) {
+                            moduleInfo.copyright = `${moduleInfo.copyright}*`;
+                        }
+                    }
+                }
+            }
+        }
+    });
+    if (!passedClarificationCheck) {
+        throw new Error("All clarifications must come with a checksum");
+    }
+    // TODO: How do clarifications interact with notice files?
+    noticeFiles.forEach((filename) => {
+        const packagePath = currentExtendedPackageJson.path;
+        if (!packagePath)
+            return;
+        const file = path.join(packagePath, filename);
+        if (fs.lstatSync(file).isFile()) {
+            moduleInfo.noticeFile = options.basePath
+                ? path.relative(options.basePath, file)
+                : file;
+        }
+    });
+    if (!currentExtendedPackageJson.name || !currentExtendedPackageJson.version) {
+        delete data[currentPackageNameAndVersion];
+    }
+    if (options.customFormat) {
+        Object.keys(options.customFormat).forEach((customFormatKey) => {
+            if (mustInclude(customFormatKey) &&
+                moduleInfo[customFormatKey] === undefined) {
+                const value = firstDefined(clarification?.[customFormatKey], typeof currentExtendedPackageJson[customFormatKey] === "string"
+                    ? currentExtendedPackageJson[customFormatKey]
+                    : options.customFormat?.[customFormatKey]);
+                if (typeof value === "string" || typeof value === "boolean") {
+                    moduleInfo[customFormatKey] = value;
+                }
+            }
+        });
+    }
+    return true;
+};
+/**
+ * @param {{
+ *   args?: Record<string, unknown>,
+ *   basePath?: string | null,
+ *   clarifications?: Record<string, Array<Record<string, unknown>>>,
+ *   customFormat?: Record<string, unknown>,
+ *   development?: boolean,
+ *   direct?: number | boolean | string | null,
+ *   production?: boolean,
+ *   rootPackage: Record<string, unknown>,
+ *   unknown?: boolean
+ * }} options
+ * @returns {Record<string, Record<string, unknown>>}
+ */
+export const collectLicenseResults = ({ args, basePath, clarifications = {}, customFormat, development, direct, production, rootPackage, unknown, }) => {
+    const data = {};
+    const options = {
+        args: args ? { csv: args.csv } : undefined,
+        basePath,
+        clarifications,
+        customFormat,
+        development,
+        production,
+        unknown,
+    };
+    walkDependencyTree(rootPackage, {
+        maxDepth: direct,
+        shouldVisit: (dependency) => !data[getPackageNameAndVersion(dependency)],
+        visit: (packageJson) => collectPackageLicenseInfo({ packageJson, data, options }),
+    });
+    return data;
+};

package/dist/licenses/copyright.d.ts

@@ -0,0 +1 @@
+export declare function getCopyrightLines(fileContents?: string): string[];

package/dist/licenses/copyright.js

@@ -0,0 +1,13 @@
+export function getCopyrightLines(fileContents = "") {
+    return fileContents
+        .replace(/\r\n/g, "\n")
+        .split("\n\n")
+        .filter(function selectCopyRightStatements(value) {
+        return (value.startsWith("opyright", 1) && // include copyright statements
+            !value.startsWith("opyright notice", 1) && // exclude lines from from license text
+            !value.startsWith("opyright and related rights", 1));
+    })
+        .filter(function removeDuplicates(value, index, list) {
+        return index === 0 || value !== list[0];
+    });
+}

package/dist/licenses/detect-license-title.d.ts

@@ -0,0 +1 @@
+export declare const detectLicenseTitle: (str?: string) => string | null;

package/dist/licenses/detect-license-title.js

@@ -0,0 +1,145 @@
+import { parseSpdxExpression } from "./spdx.js";
+const MIT_LICENSE = /ermission is hereby granted, free of charge, to any/;
+const BSD_LICENSE = /edistribution and use in source and binary forms, with or withou/;
+const BSD_SOURCE_CODE_LICENSE = /edistribution and use of this software in source and binary forms, with or withou/;
+const WTFPL_LICENSE = /DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE/;
+const ISC_LICENSE = /The ISC License/;
+const HIPPOCRATIC_LICENSE = /Hippocratic License/;
+const MIT = /\bMIT\b/;
+const BSD = /\bBSD\b/;
+const ISC = /\bISC\b/;
+const GPL = /\bGNU GENERAL PUBLIC LICENSE\s*Version ([^,]*)/i;
+const LGPL = /(?:LESSER|LIBRARY) GENERAL PUBLIC LICENSE\s*Version ([^,]*)/i;
+const APACHE_VERSION = /\bApache License\s*Version ([^,\s]*)/i;
+const APACHE = /\bApache License\b/;
+const APACHE_VERSION_SHORT = /\bApache ([^,\s]*)/i;
+const WTFPL = /\bWTFPL\b/;
+const ZERO_PARITY_LICENSE = /\bParity\b/;
+// https://creativecommons.org/publicdomain/zero/1.0/
+const CC0_1_0 = /The\s+person\s+who\s+associated\s+a\s+work\s+with\s+this\s+deed\s+has\s+dedicated\s+the\s+work\s+to\s+the\s+public\s+domain\s+by\s+waiving\s+all\s+of\s+his\s+or\s+her\s+rights\s+to\s+the\s+work\s+worldwide\s+under\s+copyright\s+law,\s+including\s+all\s+related\s+and\s+neighboring\s+rights,\s+to\s+the\s+extent\s+allowed\s+by\s+law.\s+You\s+can\s+copy,\s+modify,\s+distribute\s+and\s+perform\s+the\s+work,\s+even\s+for\s+commercial\s+purposes,\s+all\s+without\s+asking\s+permission./i; // jshint ignore:line
+const PUBLIC_DOMAIN = /[Pp]ublic[-_ ]*[Dd]omain/;
+const IS_URL = /(https?:\/\/[-a-zA-Z0-9/.]*)/;
+const CONTAINS_URLS_ENDING_WITH = /(.svg|.gif|.png|.jpg|.jpeg)$/i;
+const CONTAINS_LICENSE_TERM = /(license|licence|lizenz)/gi;
+const IS_FILE_REFERENCE = /SEE LICENSE IN (.*)/i;
+const UNLICENSED = /UNLICENSED/i;
+export const detectLicenseTitle = (str = "undefined") => {
+    if (typeof str !== "string") {
+        throw new Error(`Wrong type for parameter "str" ("${str}"): Must be of type string`);
+    }
+    let match;
+    let version;
+    try {
+        // Simply check if the string is a valid SPDX expression:
+        parseSpdxExpression(str);
+        // No need for additional parsing efforts:
+        return str;
+    }
+    catch {
+        // Fail silently and continue with additional parsing efforts:
+    }
+    if (str) {
+        // biome-ignore lint/style/noParameterAssign: TODO this whole function is a bit funky, and I'm too lazy to clean this up NOW :D
+        str = str.replace("\n", "");
+    }
+    if (!str || str === "undefined") {
+        return "Undefined";
+    }
+    if (ZERO_PARITY_LICENSE.test(str)) {
+        return "Zero Parity*";
+    }
+    if (ISC_LICENSE.test(str)) {
+        return "ISC*";
+    }
+    if (HIPPOCRATIC_LICENSE.test(str)) {
+        return "Hippocratic-2.1*";
+    }
+    if (MIT_LICENSE.test(str)) {
+        return "MIT*";
+    }
+    if (BSD_LICENSE.test(str)) {
+        return "BSD*";
+    }
+    if (BSD_SOURCE_CODE_LICENSE.test(str)) {
+        // https://spdx.org/licenses/BSD-Source-Code.html
+        return "BSD-Source-Code*";
+    }
+    if (WTFPL_LICENSE.test(str)) {
+        return "WTFPL*";
+    }
+    if (ISC.test(str)) {
+        return "ISC*";
+    }
+    if (MIT.test(str)) {
+        return "MIT*";
+    }
+    if (BSD.test(str)) {
+        return "BSD*";
+    }
+    if (WTFPL.test(str)) {
+        return "WTFPL*";
+    }
+    if (APACHE_VERSION.test(str)) {
+        match = APACHE_VERSION.exec(str);
+        if (!match)
+            return null;
+        version = match[1] ?? "";
+        if (version.length === 1) {
+            version = `${version}.0`;
+        }
+        return `Apache-${version}*`;
+    }
+    if (APACHE.test(str)) {
+        return "Apache*";
+    }
+    if (APACHE_VERSION_SHORT.test(str)) {
+        match = APACHE_VERSION_SHORT.exec(str);
+        if (!match)
+            return null;
+        version = match[1] ?? "";
+        if (version.length === 1) {
+            version = `${version}.0`;
+        }
+        return `Apache-${version}*`;
+    }
+    if (CC0_1_0.test(str)) {
+        return "CC0-1.0*";
+    }
+    if (GPL.test(str)) {
+        match = GPL.exec(str);
+        if (!match)
+            return null;
+        version = match[1] ?? "";
+        if (version.length === 1) {
+            version = `${version}.0`;
+        }
+        return `GPL-${version}*`;
+    }
+    if (LGPL.test(str)) {
+        match = LGPL.exec(str);
+        if (!match)
+            return null;
+        version = match[1] ?? "";
+        if (version.length === 1) {
+            version = `${version}.0`;
+        }
+        return `LGPL-${version}*`;
+    }
+    if (PUBLIC_DOMAIN.test(str)) {
+        return "Public Domain";
+    }
+    if (UNLICENSED.test(str)) {
+        return "UNLICENSED";
+    }
+    match = IS_URL.exec(str) || IS_FILE_REFERENCE.exec(str);
+    if (match) {
+        const matchedUrl = match[1];
+        CONTAINS_LICENSE_TERM.lastIndex = 0;
+        CONTAINS_URLS_ENDING_WITH.lastIndex = 0;
+        if (CONTAINS_LICENSE_TERM.test(str) &&
+            !CONTAINS_URLS_ENDING_WITH.test(matchedUrl)) {
+            return `Custom: ${matchedUrl}`;
+        }
+    }
+    return null;
+};

package/dist/licenses/find-license-files.d.ts

@@ -0,0 +1 @@
+export declare const findLicenseFiles: (dirFiles: string[]) => string[];

package/dist/licenses/find-license-files.js

@@ -0,0 +1,26 @@
+import path from "node:path";
+const BASENAMES_PRECEDENCE = [
+    /^LICENSE$/,
+    /^LICENSE-\w+$/, // e.g. LICENSE-MIT
+    /^LICENCE$/,
+    /^LICENCE-\w+$/, // e.g. LICENCE-MIT
+    /^MIT-LICENSE$/,
+    /^COPYING$/,
+    /^README$/, // TODO: should we really include README?
+];
+// Find and list license files in the precedence order
+export const findLicenseFiles = (dirFiles) => {
+    const files = [];
+    BASENAMES_PRECEDENCE.forEach((basenamePattern) => {
+        dirFiles.some((filename) => {
+            const basename = getBaseFileName(filename);
+            if (basenamePattern.test(basename)) {
+                files.push(filename);
+                return true;
+            }
+            return false;
+        });
+    });
+    return files;
+};
+const getBaseFileName = (filename) => path.basename(filename, path.extname(filename)).toUpperCase();

package/dist/licenses/package-metadata.d.ts

@@ -0,0 +1,20 @@
+import type { Clarification, DependencyPackage } from "../types.js";
+export declare function getRepositoryUrl({ clarificationRepository, jsonRepository, }: {
+    clarificationRepository?: string;
+    jsonRepository?: string | {
+        url?: string;
+    };
+}): string | undefined;
+export declare function getAuthorDetails({ clarification, author, }: {
+    clarification?: Clarification;
+    author?: {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+}): {
+    publisher?: string;
+    email?: string;
+    url?: string;
+};
+export declare const storeReadmeInPackageJsonIfExists: (modulePath: string | undefined, currentExtendedPackageJson: DependencyPackage) => void;

package/dist/licenses/package-metadata.js

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { firstDefined } from "../shared/first-defined.js";
+export function getRepositoryUrl({ clarificationRepository, jsonRepository, }) {
+    if (clarificationRepository) {
+        return clarificationRepository;
+    }
+    const repositoryUrl = typeof jsonRepository === "object" ? jsonRepository?.url : undefined;
+    if (typeof repositoryUrl === "string") {
+        return repositoryUrl
+            .replace("git+ssh://git@", "git://")
+            .replace("git+https://github.com", "https://github.com")
+            .replace("git://github.com", "https://github.com")
+            .replace("git@github.com:", "https://github.com/")
+            .replace(/\.git$/, "");
+    }
+}
+export function getAuthorDetails({ clarification, author, }) {
+    const publisher = firstDefined(clarification?.publisher, author?.name);
+    const email = firstDefined(clarification?.email, author?.email);
+    const url = firstDefined(clarification?.url, author?.url);
+    return { publisher, email, url };
+}
+// Eventually store the contents of the module's README.md in currentExtendedPackageJson.readme:
+export const storeReadmeInPackageJsonIfExists = (modulePath, currentExtendedPackageJson) => {
+    if (typeof modulePath !== "string" ||
+        typeof currentExtendedPackageJson !== "object" ||
+        modulePath === "" ||
+        (typeof currentExtendedPackageJson?.readme === "string" &&
+            currentExtendedPackageJson?.readme
+                ?.toLowerCase()
+                ?.indexOf("no readme data found") === -1)) {
+        return;
+    }
+    const readmeFile = path.join(modulePath, "README.md");
+    if (fs.existsSync(readmeFile)) {
+        currentExtendedPackageJson.readme = fs
+            .readFileSync(readmeFile, "utf8")
+            .toString();
+    }
+};

package/dist/licenses/spdx-data.d.ts

@@ -0,0 +1,4 @@
+export declare const SPDX_LICENSE_IDS: readonly ["0BSD", "3D-Slicer-1.0", "AAL", "ADSL", "AFL-1.1", "AFL-1.2", "AFL-2.0", "AFL-2.1", "AFL-3.0", "AGPL-1.0-only", "AGPL-1.0-or-later", "AGPL-3.0-only", "AGPL-3.0-or-later", "ALGLIB-Documentation", "AMD-newlib", "AMDPLPA", "AML", "AML-glslang", "AMPAS", "ANTLR-PD", "ANTLR-PD-fallback", "APAFML", "APL-1.0", "APSL-1.0", "APSL-1.1", "APSL-1.2", "APSL-2.0", "ASWF-Digital-Assets-1.0", "ASWF-Digital-Assets-1.1", "Abstyles", "AdaCore-doc", "Adobe-2006", "Adobe-Display-PostScript", "Adobe-Glyph", "Adobe-Utopia", "Advanced-Cryptics-Dictionary", "Afmparse", "Aladdin", "Apache-1.0", "Apache-1.1", "Apache-2.0", "App-s2p", "Arphic-1999", "Artistic-1.0", "Artistic-1.0-Perl", "Artistic-1.0-cl8", "Artistic-2.0", "Artistic-dist", "Aspell-RU", "BOLA-1.1", "BSD-1-Clause", "BSD-2-Clause", "BSD-2-Clause-Darwin", "BSD-2-Clause-Patent", "BSD-2-Clause-Views", "BSD-2-Clause-first-lines", "BSD-2-Clause-pkgconf-disclaimer", "BSD-2-Clause-pos-unchanged", "BSD-3-Clause", "BSD-3-Clause-Attribution", "BSD-3-Clause-Clear", "BSD-3-Clause-HP", "BSD-3-Clause-LBNL", "BSD-3-Clause-Modification", "BSD-3-Clause-No-Military-License", "BSD-3-Clause-No-Nuclear-License", "BSD-3-Clause-No-Nuclear-License-2014", "BSD-3-Clause-No-Nuclear-Warranty", "BSD-3-Clause-Open-MPI", "BSD-3-Clause-OpenWebUI", "BSD-3-Clause-Sun", "BSD-3-Clause-Tso", "BSD-3-Clause-acpica", "BSD-3-Clause-flex", "BSD-4-Clause", "BSD-4-Clause-Shortened", "BSD-4-Clause-UC", "BSD-4.3RENO", "BSD-4.3TAHOE", "BSD-Advertising-Acknowledgement", "BSD-Attribution-HPND-disclaimer", "BSD-Inferno-Nettverk", "BSD-Mark-Modifications", "BSD-Protection", "BSD-Source-Code", "BSD-Source-Code-no-disclaimer", "BSD-Source-alt-GPL", "BSD-Source-beginning-file", "BSD-Systemics", "BSD-Systemics-W3Works", "BSD-ask-to-endorse", "BSL-1.0", "BUSL-1.1", "Baekmuk", "Bahyph", "Barr", "Beerware", "BitTorrent-1.0", "BitTorrent-1.1", "Bitstream-Charter", "Bitstream-Vera", "BlueOak-1.0.0", "Boehm-GC", "Boehm-GC-without-fee", "Borceux", "Brian-Gladman-2-Clause", "Brian-Gladman-3-Clause", "Brian-Gladman-3-Clause-no-conversion", "Buddy", "Bugroff", "C-UDA-1.0", "CAL-1.0", "CAL-1.0-Combined-Work-Exception", "CAPEC-tou", "CATOSL-1.1", "CC-BY-1.0", "CC-BY-2.0", "CC-BY-2.5", "CC-BY-2.5-AU", "CC-BY-3.0", "CC-BY-3.0-AT", "CC-BY-3.0-AU", "CC-BY-3.0-DE", "CC-BY-3.0-IGO", "CC-BY-3.0-NL", "CC-BY-3.0-US", "CC-BY-4.0", "CC-BY-NC-1.0", "CC-BY-NC-2.0", "CC-BY-NC-2.5", "CC-BY-NC-3.0", "CC-BY-NC-3.0-DE", "CC-BY-NC-3.0-IGO", "CC-BY-NC-4.0", "CC-BY-NC-ND-1.0", "CC-BY-NC-ND-2.0", "CC-BY-NC-ND-2.5", "CC-BY-NC-ND-3.0", "CC-BY-NC-ND-3.0-DE", "CC-BY-NC-ND-3.0-IGO", "CC-BY-NC-ND-4.0", "CC-BY-NC-SA-1.0", "CC-BY-NC-SA-2.0", "CC-BY-NC-SA-2.0-DE", "CC-BY-NC-SA-2.0-FR", "CC-BY-NC-SA-2.0-UK", "CC-BY-NC-SA-2.5", "CC-BY-NC-SA-3.0", "CC-BY-NC-SA-3.0-DE", "CC-BY-NC-SA-3.0-IGO", "CC-BY-NC-SA-4.0", "CC-BY-ND-1.0", "CC-BY-ND-2.0", "CC-BY-ND-2.5", "CC-BY-ND-3.0", "CC-BY-ND-3.0-DE", "CC-BY-ND-4.0", "CC-BY-SA-1.0", "CC-BY-SA-2.0", "CC-BY-SA-2.0-UK", "CC-BY-SA-2.1-JP", "CC-BY-SA-2.5", "CC-BY-SA-3.0", "CC-BY-SA-3.0-AT", "CC-BY-SA-3.0-DE", "CC-BY-SA-3.0-IGO", "CC-BY-SA-4.0", "CC-PDDC", "CC-PDM-1.0", "CC-SA-1.0", "CC0-1.0", "CDDL-1.0", "CDDL-1.1", "CDL-1.0", "CDLA-Permissive-1.0", "CDLA-Permissive-2.0", "CDLA-Sharing-1.0", "CECILL-1.0", "CECILL-1.1", "CECILL-2.0", "CECILL-2.1", "CECILL-B", "CECILL-C", "CERN-OHL-1.1", "CERN-OHL-1.2", "CERN-OHL-P-2.0", "CERN-OHL-S-2.0", "CERN-OHL-W-2.0", "CFITSIO", "CMU-Mach", "CMU-Mach-nodoc", "CNRI-Jython", "CNRI-Python", "CNRI-Python-GPL-Compatible", "COIL-1.0", "CPAL-1.0", "CPL-1.0", "CPOL-1.02", "CUA-OPL-1.0", "Caldera", "Caldera-no-preamble", "Catharon", "ClArtistic", "Clips", "Community-Spec-1.0", "Condor-1.1", "Cornell-Lossless-JPEG", "Cronyx", "Crossword", "CryptoSwift", "CrystalStacker", "Cube", "D-FSL-1.0", "DEC-3-Clause", "DL-DE-BY-2.0", "DL-DE-ZERO-2.0", "DOC", "DRL-1.0", "DRL-1.1", "DSDP", "DocBook-DTD", "DocBook-Schema", "DocBook-Stylesheet", "DocBook-XML", "Dotseqn", "ECL-1.0", "ECL-2.0", "EFL-1.0", "EFL-2.0", "EPICS", "EPL-1.0", "EPL-2.0", "ESA-PL-permissive-2.4", "ESA-PL-strong-copyleft-2.4", "ESA-PL-weak-copyleft-2.4", "EUDatagrid", "EUPL-1.0", "EUPL-1.1", "EUPL-1.2", "Elastic-2.0", "Entessa", "ErlPL-1.1", "Eurosym", "FBM", "FDK-AAC", "FDK-MPEG-H", "FSFAP", "FSFAP-no-warranty-disclaimer", "FSFUL", "FSFULLR", "FSFULLRSD", "FSFULLRWD", "FSL-1.1-ALv2", "FSL-1.1-MIT", "FTL", "Fair", "Ferguson-Twofish", "Frameworx-1.0", "FreeBSD-DOC", "FreeImage", "Furuseth", "GCR-docs", "GD", "GFDL-1.1-invariants-only", "GFDL-1.1-invariants-or-later", "GFDL-1.1-no-invariants-only", "GFDL-1.1-no-invariants-or-later", "GFDL-1.1-only", "GFDL-1.1-or-later", "GFDL-1.2-invariants-only", "GFDL-1.2-invariants-or-later", "GFDL-1.2-no-invariants-only", "GFDL-1.2-no-invariants-or-later", "GFDL-1.2-only", "GFDL-1.2-or-later", "GFDL-1.3-invariants-only", "GFDL-1.3-invariants-or-later", "GFDL-1.3-no-invariants-only", "GFDL-1.3-no-invariants-or-later", "GFDL-1.3-only", "GFDL-1.3-or-later", "GL2PS", "GLWTPL", "GPL-1.0-only", "GPL-1.0-or-later", "GPL-2.0-only", "GPL-2.0-or-later", "GPL-3.0-only", "GPL-3.0-or-later", "Game-Programming-Gems", "Giftware", "Glide", "Glulxe", "Graphics-Gems", "Gutmann", "HDF5", "HIDAPI", "HP-1986", "HP-1989", "HPND", "HPND-DEC", "HPND-Fenneberg-Livingston", "HPND-INRIA-IMAG", "HPND-Intel", "HPND-Kevlin-Henney", "HPND-MIT-disclaimer", "HPND-Markus-Kuhn", "HPND-Netrek", "HPND-Pbmplus", "HPND-SMC", "HPND-UC", "HPND-UC-export-US", "HPND-doc", "HPND-doc-sell", "HPND-export-US", "HPND-export-US-acknowledgement", "HPND-export-US-modify", "HPND-export2-US", "HPND-merchantability-variant", "HPND-sell-MIT-disclaimer-xserver", "HPND-sell-regexpr", "HPND-sell-variant", "HPND-sell-variant-MIT-disclaimer", "HPND-sell-variant-MIT-disclaimer-rev", "HPND-sell-variant-critical-systems", "HTMLTIDY", "HaskellReport", "Hippocratic-2.1", "Hippocratic-3.0-core", "IBM-pibs", "ICU", "IEC-Code-Components-EULA", "IJG", "IJG-short", "IPA", "IPL-1.0", "ISC", "ISC-Veillard", "ISO-permission", "ImageMagick", "Imlib2", "Info-ZIP", "Informatica", "Inner-Net-2.0", "InnoSetup", "Intel", "Intel-ACPI", "Interbase-1.0", "JPL-image", "JPNIC", "JSON", "Jam", "JasPer-2.0", "Kastrup", "Kazlib", "Knuth-CTAN", "LAL-1.2", "LAL-1.3", "LGPL-2.0-only", "LGPL-2.0-or-later", "LGPL-2.1-only", "LGPL-2.1-or-later", "LGPL-3.0-only", "LGPL-3.0-or-later", "LGPLLR", "LOOP", "LPD-document", "LPL-1.0", "LPL-1.02", "LPPL-1.0", "LPPL-1.1", "LPPL-1.2", "LPPL-1.3a", "LPPL-1.3c", "LZMA-SDK-9.11-to-9.20", "LZMA-SDK-9.22", "Latex2e", "Latex2e-translated-notice", "Leptonica", "LiLiQ-P-1.1", "LiLiQ-R-1.1", "LiLiQ-Rplus-1.1", "Libpng", "Linux-OpenIB", "Linux-man-pages-1-para", "Linux-man-pages-copyleft", "Linux-man-pages-copyleft-2-para", "Linux-man-pages-copyleft-var", "Lucida-Bitmap-Fonts", "MIPS", "MIT", "MIT-0", "MIT-CMU", "MIT-Click", "MIT-Festival", "MIT-Khronos-old", "MIT-Modern-Variant", "MIT-STK", "MIT-Wu", "MIT-advertising", "MIT-enna", "MIT-feh", "MIT-open-group", "MIT-testregex", "MITNFA", "MMIXware", "MMPL-1.0.1", "MPEG-SSG", "MPL-1.0", "MPL-1.1", "MPL-2.0", "MPL-2.0-no-copyleft-exception", "MS-LPL", "MS-PL", "MS-RL", "MTLL", "MVT-1.1", "Mackerras-3-Clause", "Mackerras-3-Clause-acknowledgment", "MakeIndex", "Martin-Birgmeier", "McPhee-slideshow", "Minpack", "MirOS", "Motosoto", "MulanPSL-1.0", "MulanPSL-2.0", "Multics", "Mup", "NAIST-2003", "NASA-1.3", "NBPL-1.0", "NCBI-PD", "NCGL-UK-2.0", "NCL", "NCSA", "NGPL", "NICTA-1.0", "NIST-PD", "NIST-PD-TNT", "NIST-PD-fallback", "NIST-Software", "NLOD-1.0", "NLOD-2.0", "NLPL", "NOSL", "NPL-1.0", "NPL-1.1", "NPOSL-3.0", "NRL", "NTIA-PD", "NTP", "NTP-0", "Naumen", "NetCDF", "Newsletr", "Nokia", "Noweb", "O-UDA-1.0", "OAR", "OCCT-PL", "OCLC-2.0", "ODC-By-1.0", "ODbL-1.0", "OFFIS", "OFL-1.0", "OFL-1.0-RFN", "OFL-1.0-no-RFN", "OFL-1.1", "OFL-1.1-RFN", "OFL-1.1-no-RFN", "OGC-1.0", "OGDL-Taiwan-1.0", "OGL-Canada-2.0", "OGL-UK-1.0", "OGL-UK-2.0", "OGL-UK-3.0", "OGTSL", "OLDAP-1.1", "OLDAP-1.2", "OLDAP-1.3", "OLDAP-1.4", "OLDAP-2.0", "OLDAP-2.0.1", "OLDAP-2.1", "OLDAP-2.2", "OLDAP-2.2.1", "OLDAP-2.2.2", "OLDAP-2.3", "OLDAP-2.4", "OLDAP-2.5", "OLDAP-2.6", "OLDAP-2.7", "OLDAP-2.8", "OLFL-1.3", "OML", "OPL-1.0", "OPL-UK-3.0", "OPUBL-1.0", "OSC-1.0", "OSET-PL-2.1", "OSL-1.0", "OSL-1.1", "OSL-2.0", "OSL-2.1", "OSL-3.0", "OSSP", "OpenMDW-1.0", "OpenPBS-2.3", "OpenSSL", "OpenSSL-standalone", "OpenVision", "PADL", "PDDL-1.0", "PHP-3.0", "PHP-3.01", "PPL", "PSF-2.0", "ParaType-Free-Font-1.3", "Parity-6.0.0", "Parity-7.0.0", "Pixar", "Plexus", "PolyForm-Noncommercial-1.0.0", "PolyForm-Small-Business-1.0.0", "PostgreSQL", "Python-2.0", "Python-2.0.1", "QPL-1.0", "QPL-1.0-INRIA-2004", "Qhull", "RHeCos-1.1", "RPL-1.1", "RPL-1.5", "RPSL-1.0", "RSA-MD", "RSCPL", "Rdisc", "Ruby", "Ruby-pty", "SAX-PD", "SAX-PD-2.0", "SCEA", "SGI-B-1.0", "SGI-B-1.1", "SGI-B-2.0", "SGI-OpenGL", "SGMLUG-PM", "SGP4", "SHL-0.5", "SHL-0.51", "SISSL", "SISSL-1.2", "SL", "SMAIL-GPL", "SMLNJ", "SMPPL", "SNIA", "SOFA", "SPL-1.0", "SSH-OpenSSH", "SSH-short", "SSLeay-standalone", "SSPL-1.0", "SUL-1.0", "SWL", "Saxpath", "SchemeReport", "Sendmail", "Sendmail-8.23", "Sendmail-Open-Source-1.1", "SimPL-2.0", "Sleepycat", "Soundex", "Spencer-86", "Spencer-94", "Spencer-99", "SugarCRM-1.1.3", "Sun-PPP", "Sun-PPP-2000", "SunPro", "Symlinks", "TAPR-OHL-1.0", "TCL", "TCP-wrappers", "TGPPL-1.0", "TMate", "TORQUE-1.1", "TOSL", "TPDL", "TPL-1.0", "TTWL", "TTYP0", "TU-Berlin-1.0", "TU-Berlin-2.0", "TekHVC", "TermReadKey", "ThirdEye", "TrustedQSL", "UCAR", "UCL-1.0", "UMich-Merit", "UPL-1.0", "URT-RLE", "Ubuntu-font-1.0", "UnRAR", "Unicode-3.0", "Unicode-DFS-2015", "Unicode-DFS-2016", "Unicode-TOU", "UnixCrypt", "Unlicense", "Unlicense-libtelnet", "Unlicense-libwhirlpool", "VOSTROM", "VSL-1.0", "Vim", "Vixie-Cron", "W3C", "W3C-19980720", "W3C-20150513", "WTFNMFPL", "WTFPL", "Watcom-1.0", "Widget-Workshop", "WordNet", "Wsuipa", "X11", "X11-distribute-modifications-variant", "X11-no-permit-persons", "X11-swapped", "XFree86-1.1", "XSkat", "Xdebug-1.03", "Xerox", "Xfig", "Xnet", "YPL-1.0", "YPL-1.1", "ZPL-1.1", "ZPL-2.0", "ZPL-2.1", "Zed", "Zeeff", "Zend-2.0", "Zimbra-1.3", "Zimbra-1.4", "Zlib", "any-OSI", "any-OSI-perl-modules", "atc-game", "bcrypt-Solar-Designer", "blessing", "bzip2-1.0.6", "check-cvs", "checkmk", "copyleft-next-0.3.0", "copyleft-next-0.3.1", "curl", "cve-tou", "diffmark", "dtoa", "dvipdfm", "eGenix", "etalab-2.0", "fwlw", "gSOAP-1.3b", "generic-xts", "gnuplot", "gtkbook", "hdparm", "hyphen-bulgarian", "iMatix", "jove", "libpng-1.6.35", "libpng-2.0", "libselinux-1.0", "libtiff", "libutil-David-Nugent", "lsof", "magaz", "mailprio", "man2html", "metamail", "mpi-permissive", "mpich2", "mplus", "ngrep", "pkgconf", "pnmstitch", "psfrag", "psutils", "python-ldap", "radvd", "snprintf", "softSurfer", "ssh-keyscan", "swrule", "threeparttable", "ulem", "w3m", "wwl", "xinetd", "xkeyboard-config-Zinoviev", "xlock", "xpp", "xzoom", "zlib-acknowledgement"];
+export declare const SPDX_DEPRECATED_LICENSE_IDS: readonly ["AGPL-1.0", "AGPL-3.0", "BSD-2-Clause-FreeBSD", "BSD-2-Clause-NetBSD", "GFDL-1.1", "GFDL-1.2", "GFDL-1.3", "GPL-1.0", "GPL-2.0", "GPL-2.0-with-GCC-exception", "GPL-2.0-with-autoconf-exception", "GPL-2.0-with-bison-exception", "GPL-2.0-with-classpath-exception", "GPL-2.0-with-font-exception", "GPL-3.0", "GPL-3.0-with-GCC-exception", "GPL-3.0-with-autoconf-exception", "LGPL-2.0", "LGPL-2.1", "LGPL-3.0", "Net-SNMP", "Nunit", "StandardML-NJ", "bzip2-1.0.5", "eCos-2.0", "wxWindows"];
+export declare const SPDX_EXCEPTION_IDS: readonly ["389-exception", "Asterisk-exception", "Autoconf-exception-2.0", "Autoconf-exception-3.0", "Autoconf-exception-generic", "Autoconf-exception-generic-3.0", "Autoconf-exception-macro", "Bison-exception-1.24", "Bison-exception-2.2", "Bootloader-exception", "Classpath-exception-2.0", "CLISP-exception-2.0", "cryptsetup-OpenSSL-exception", "DigiRule-FOSS-exception", "eCos-exception-2.0", "Fawkes-Runtime-exception", "FLTK-exception", "fmt-exception", "Font-exception-2.0", "freertos-exception-2.0", "GCC-exception-2.0", "GCC-exception-2.0-note", "GCC-exception-3.1", "Gmsh-exception", "GNAT-exception", "GNOME-examples-exception", "GNU-compiler-exception", "gnu-javamail-exception", "GPL-3.0-interface-exception", "GPL-3.0-linking-exception", "GPL-3.0-linking-source-exception", "GPL-CC-1.0", "GStreamer-exception-2005", "GStreamer-exception-2008", "i2p-gpl-java-exception", "KiCad-libraries-exception", "LGPL-3.0-linking-exception", "libpri-OpenH323-exception", "Libtool-exception", "Linux-syscall-note", "LLGPL", "LLVM-exception", "LZMA-exception", "mif-exception", "OCaml-LGPL-linking-exception", "OCCT-exception-1.0", "OpenJDK-assembly-exception-1.0", "openvpn-openssl-exception", "PS-or-PDF-font-exception-20170817", "QPL-1.0-INRIA-2004-exception", "Qt-GPL-exception-1.0", "Qt-LGPL-exception-1.1", "Qwt-exception-1.0", "SANE-exception", "SHL-2.0", "SHL-2.1", "stunnel-exception", "SWI-exception", "Swift-exception", "Texinfo-exception", "u-boot-exception-2.0", "UBDL-exception", "Universal-FOSS-exception-1.0", "vsftpd-openssl-exception", "WxWindows-exception-3.1", "x11vnc-openssl-exception"];
+export declare const SPDX_VERSION_RANGES: readonly [readonly ["AFL-1.1", "AFL-1.2", "AFL-2.0", "AFL-2.1", "AFL-3.0"], readonly ["AGPL-1.0", readonly ["AGPL-3.0", "AGPL-3.0-only"]], readonly ["Apache-1.0", "Apache-1.1", "Apache-2.0"], readonly ["APSL-1.0", "APSL-1.1", "APSL-1.2", "APSL-2.0"], readonly ["Artistic-1.0", "Artistic-2.0"], readonly ["BitTorrent-1.0", "BitTorrent-1.1"], readonly ["CC-BY-1.0", "CC-BY-2.0", "CC-BY-2.5", "CC-BY-3.0", "CC-BY-4.0"], readonly ["CC-BY-NC-1.0", "CC-BY-NC-2.0", "CC-BY-NC-2.5", "CC-BY-NC-3.0", "CC-BY-NC-4.0"], readonly ["CC-BY-NC-ND-1.0", "CC-BY-NC-ND-2.0", "CC-BY-NC-ND-2.5", "CC-BY-NC-ND-3.0", "CC-BY-NC-ND-4.0"], readonly ["CC-BY-NC-SA-1.0", "CC-BY-NC-SA-2.0", "CC-BY-NC-SA-2.5", "CC-BY-NC-SA-3.0", "CC-BY-NC-SA-4.0"], readonly ["CC-BY-ND-1.0", "CC-BY-ND-2.0", "CC-BY-ND-2.5", "CC-BY-ND-3.0", "CC-BY-ND-4.0"], readonly ["CC-BY-SA-1.0", "CC-BY-SA-2.0", "CC-BY-SA-2.5", "CC-BY-SA-3.0", "CC-BY-SA-4.0"], readonly ["CDDL-1.0", "CDDL-1.1"], readonly ["CECILL-1.0", "CECILL-1.1", "CECILL-2.0"], readonly ["ECL-1.0", "ECL-2.0"], readonly ["EFL-1.0", "EFL-2.0"], readonly ["EPL-1.0", "EPL-2.0"], readonly ["EUPL-1.0", "EUPL-1.1"], readonly [readonly ["GFDL-1.1", "GFDL-1.1-only"], readonly ["GFDL-1.2", "GFDL-1.2-only"], readonly ["GFDL-1.1-or-later", "GFDL-1.2-or-later", "GFDL-1.3", "GFDL-1.3-only", "GFDL-1.3-or-later"]], readonly [readonly ["GPL-1.0", "GPL-1.0-only"], readonly ["GPL-2.0", "GPL-2.0-only"], readonly ["GPL-1.0-or-later", "GPL-2.0-or-later", "GPL-3.0", "GPL-3.0-only", "GPL-3.0-or-later"]], readonly [readonly ["LGPL-2.0", "LGPL-2.0-only"], readonly ["LGPL-2.1", "LGPL-2.1-only"], readonly ["LGPL-2.0-or-later", "LGPL-2.1-or-later", "LGPL-3.0", "LGPL-3.0-only", "LGPL-3.0-or-later"]], readonly ["LPL-1.0", "LPL-1.02"], readonly ["LPPL-1.0", "LPPL-1.1", "LPPL-1.2", "LPPL-1.3a", "LPPL-1.3c"], readonly ["MPL-1.0", "MPL-1.1", "MPL-2.0"], readonly ["MPL-1.0", "MPL-1.1", "MPL-2.0-no-copyleft-exception"], readonly ["NPL-1.0", "NPL-1.1"], readonly ["OFL-1.0", "OFL-1.1"], readonly ["OLDAP-1.1", "OLDAP-1.2", "OLDAP-1.3", "OLDAP-1.4", "OLDAP-2.0", "OLDAP-2.0.1", "OLDAP-2.1", "OLDAP-2.2", "OLDAP-2.2.1", "OLDAP-2.2.2", "OLDAP-2.3", "OLDAP-2.4", "OLDAP-2.5", "OLDAP-2.6", "OLDAP-2.7", "OLDAP-2.8"], readonly ["OSL-1.0", "OSL-1.1", "OSL-2.0", "OSL-2.1", "OSL-3.0"], readonly ["PHP-3.0", "PHP-3.01"], readonly ["RPL-1.1", "RPL-1.5"], readonly ["SGI-B-1.0", "SGI-B-1.1", "SGI-B-2.0"], readonly ["YPL-1.0", "YPL-1.1"], readonly ["ZPL-1.1", "ZPL-2.0", "ZPL-2.1"], readonly ["Zimbra-1.3", "Zimbra-1.4"], readonly ["bzip2-1.0.5", "bzip2-1.0.6"]];