@socketsecurity/lib 5.3.0 → 5.4.0

package/dist/external/spdx-pack.js

@@ -0,0 +1,1640 @@
+"use strict";
+/**
+ * Bundled from spdx-pack
+ * This is a zero-dependency bundle created by esbuild.
+ */
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+// node_modules/.pnpm/spdx-license-ids@3.0.22/node_modules/spdx-license-ids/index.json
+var require_spdx_license_ids = __commonJS({
+  "node_modules/.pnpm/spdx-license-ids@3.0.22/node_modules/spdx-license-ids/index.json"(exports2, module2) {
+    module2.exports = [
+      "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",
+      "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",
+      "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",
+      "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-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-Sun",
+      "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-Protection",
+      "BSD-Source-Code",
+      "BSD-Source-beginning-file",
+      "BSD-Systemics",
+      "BSD-Systemics-W3Works",
+      "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",
+      "C-UDA-1.0",
+      "CAL-1.0",
+      "CAL-1.0-Combined-Work-Exception",
+      "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-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",
+      "EUDatagrid",
+      "EUPL-1.0",
+      "EUPL-1.1",
+      "EUPL-1.2",
+      "Elastic-2.0",
+      "Entessa",
+      "ErlPL-1.1",
+      "Eurosym",
+      "FBM",
+      "FDK-AAC",
+      "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-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",
+      "HTMLTIDY",
+      "HaskellReport",
+      "Hippocratic-2.1",
+      "IBM-pibs",
+      "ICU",
+      "IEC-Code-Components-EULA",
+      "IJG",
+      "IJG-short",
+      "IPA",
+      "IPL-1.0",
+      "ISC",
+      "ISC-Veillard",
+      "ImageMagick",
+      "Imlib2",
+      "Info-ZIP",
+      "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-Wu",
+      "MIT-advertising",
+      "MIT-enna",
+      "MIT-feh",
+      "MIT-open-group",
+      "MIT-testregex",
+      "MITNFA",
+      "MMIXware",
+      "MPEG-SSG",
+      "MPL-1.0",
+      "MPL-1.1",
+      "MPL-2.0",
+      "MPL-2.0-no-copyleft-exception",
+      "MS-LPL",
+      "MS-PL",
+      "MS-RL",
+      "MTLL",
+      "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-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",
+      "OSET-PL-2.1",
+      "OSL-1.0",
+      "OSL-1.1",
+      "OSL-2.0",
+      "OSL-2.1",
+      "OSL-3.0",
+      "OpenPBS-2.3",
+      "OpenSSL",
+      "OpenSSL-standalone",
+      "OpenVision",
+      "PADL",
+      "PDDL-1.0",
+      "PHP-3.0",
+      "PHP-3.01",
+      "PPL",
+      "PSF-2.0",
+      "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",
+      "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",
+      "TermReadKey",
+      "ThirdEye",
+      "TrustedQSL",
+      "UCAR",
+      "UCL-1.0",
+      "UMich-Merit",
+      "UPL-1.0",
+      "URT-RLE",
+      "Ubuntu-font-1.0",
+      "Unicode-3.0",
+      "Unicode-DFS-2015",
+      "Unicode-DFS-2016",
+      "Unicode-TOU",
+      "UnixCrypt",
+      "Unlicense",
+      "Unlicense-libtelnet",
+      "Unlicense-libwhirlpool",
+      "VOSTROM",
+      "VSL-1.0",
+      "Vim",
+      "W3C",
+      "W3C-19980720",
+      "W3C-20150513",
+      "WTFPL",
+      "Watcom-1.0",
+      "Widget-Workshop",
+      "Wsuipa",
+      "X11",
+      "X11-distribute-modifications-variant",
+      "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",
+      "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",
+      "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"
+    ];
+  }
+});
+
+// node_modules/.pnpm/spdx-license-ids@3.0.22/node_modules/spdx-license-ids/deprecated.json
+var require_deprecated = __commonJS({
+  "node_modules/.pnpm/spdx-license-ids@3.0.22/node_modules/spdx-license-ids/deprecated.json"(exports2, module2) {
+    module2.exports = [
+      "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"
+    ];
+  }
+});
+
+// node_modules/.pnpm/spdx-exceptions@2.5.0/node_modules/spdx-exceptions/index.json
+var require_spdx_exceptions = __commonJS({
+  "node_modules/.pnpm/spdx-exceptions@2.5.0/node_modules/spdx-exceptions/index.json"(exports2, module2) {
+    module2.exports = [
+      "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"
+    ];
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/scan.js
+var require_scan = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/scan.js"(exports2, module2) {
+    "use strict";
+    var licenses = [].concat(require_spdx_license_ids()).concat(require_deprecated());
+    var exceptions = require_spdx_exceptions();
+    module2.exports = function(source) {
+      var index = 0;
+      function hasMore() {
+        return index < source.length;
+      }
+      __name(hasMore, "hasMore");
+      function read(value) {
+        if (value instanceof RegExp) {
+          var chars = source.slice(index);
+          var match = chars.match(value);
+          if (match) {
+            index += match[0].length;
+            return match[0];
+          }
+        } else {
+          if (source.indexOf(value, index) === index) {
+            index += value.length;
+            return value;
+          }
+        }
+      }
+      __name(read, "read");
+      function skipWhitespace() {
+        read(/[ ]*/);
+      }
+      __name(skipWhitespace, "skipWhitespace");
+      function operator() {
+        var string;
+        var possibilities = ["WITH", "AND", "OR", "(", ")", ":", "+"];
+        for (var i = 0; i < possibilities.length; i++) {
+          string = read(possibilities[i]);
+          if (string) {
+            break;
+          }
+        }
+        if (string === "+" && index > 1 && source[index - 2] === " ") {
+          throw new Error("Space before `+`");
+        }
+        return string && {
+          type: "OPERATOR",
+          string
+        };
+      }
+      __name(operator, "operator");
+      function idstring() {
+        return read(/[A-Za-z0-9-.]+/);
+      }
+      __name(idstring, "idstring");
+      function expectIdstring() {
+        var string = idstring();
+        if (!string) {
+          throw new Error("Expected idstring at offset " + index);
+        }
+        return string;
+      }
+      __name(expectIdstring, "expectIdstring");
+      function documentRef() {
+        if (read("DocumentRef-")) {
+          var string = expectIdstring();
+          return { type: "DOCUMENTREF", string };
+        }
+      }
+      __name(documentRef, "documentRef");
+      function licenseRef() {
+        if (read("LicenseRef-")) {
+          var string = expectIdstring();
+          return { type: "LICENSEREF", string };
+        }
+      }
+      __name(licenseRef, "licenseRef");
+      function identifier() {
+        var begin = index;
+        var string = idstring();
+        if (licenses.indexOf(string) !== -1) {
+          return {
+            type: "LICENSE",
+            string
+          };
+        } else if (exceptions.indexOf(string) !== -1) {
+          return {
+            type: "EXCEPTION",
+            string
+          };
+        }
+        index = begin;
+      }
+      __name(identifier, "identifier");
+      function parseToken() {
+        return operator() || documentRef() || licenseRef() || identifier();
+      }
+      __name(parseToken, "parseToken");
+      var tokens = [];
+      while (hasMore()) {
+        skipWhitespace();
+        if (!hasMore()) {
+          break;
+        }
+        var token = parseToken();
+        if (!token) {
+          throw new Error("Unexpected `" + source[index] + "` at offset " + index);
+        }
+        tokens.push(token);
+      }
+      return tokens;
+    };
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/parse.js
+var require_parse = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/parse.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(tokens) {
+      var index = 0;
+      function hasMore() {
+        return index < tokens.length;
+      }
+      __name(hasMore, "hasMore");
+      function token() {
+        return hasMore() ? tokens[index] : null;
+      }
+      __name(token, "token");
+      function next() {
+        if (!hasMore()) {
+          throw new Error();
+        }
+        index++;
+      }
+      __name(next, "next");
+      function parseOperator(operator) {
+        var t = token();
+        if (t && t.type === "OPERATOR" && operator === t.string) {
+          next();
+          return t.string;
+        }
+      }
+      __name(parseOperator, "parseOperator");
+      function parseWith() {
+        if (parseOperator("WITH")) {
+          var t = token();
+          if (t && t.type === "EXCEPTION") {
+            next();
+            return t.string;
+          }
+          throw new Error("Expected exception after `WITH`");
+        }
+      }
+      __name(parseWith, "parseWith");
+      function parseLicenseRef() {
+        var begin = index;
+        var string = "";
+        var t = token();
+        if (t.type === "DOCUMENTREF") {
+          next();
+          string += "DocumentRef-" + t.string + ":";
+          if (!parseOperator(":")) {
+            throw new Error("Expected `:` after `DocumentRef-...`");
+          }
+        }
+        t = token();
+        if (t.type === "LICENSEREF") {
+          next();
+          string += "LicenseRef-" + t.string;
+          return { license: string };
+        }
+        index = begin;
+      }
+      __name(parseLicenseRef, "parseLicenseRef");
+      function parseLicense() {
+        var t = token();
+        if (t && t.type === "LICENSE") {
+          next();
+          var node2 = { license: t.string };
+          if (parseOperator("+")) {
+            node2.plus = true;
+          }
+          var exception = parseWith();
+          if (exception) {
+            node2.exception = exception;
+          }
+          return node2;
+        }
+      }
+      __name(parseLicense, "parseLicense");
+      function parseParenthesizedExpression() {
+        var left = parseOperator("(");
+        if (!left) {
+          return;
+        }
+        var expr = parseExpression();
+        if (!parseOperator(")")) {
+          throw new Error("Expected `)`");
+        }
+        return expr;
+      }
+      __name(parseParenthesizedExpression, "parseParenthesizedExpression");
+      function parseAtom() {
+        return parseParenthesizedExpression() || parseLicenseRef() || parseLicense();
+      }
+      __name(parseAtom, "parseAtom");
+      function makeBinaryOpParser(operator, nextParser) {
+        return /* @__PURE__ */ __name(function parseBinaryOp() {
+          var left = nextParser();
+          if (!left) {
+            return;
+          }
+          if (!parseOperator(operator)) {
+            return left;
+          }
+          var right = parseBinaryOp();
+          if (!right) {
+            throw new Error("Expected expression");
+          }
+          return {
+            left,
+            conjunction: operator.toLowerCase(),
+            right
+          };
+        }, "parseBinaryOp");
+      }
+      __name(makeBinaryOpParser, "makeBinaryOpParser");
+      var parseAnd = makeBinaryOpParser("AND", parseAtom);
+      var parseExpression = makeBinaryOpParser("OR", parseAnd);
+      var node = parseExpression();
+      if (!node || hasMore()) {
+        throw new Error("Syntax error");
+      }
+      return node;
+    };
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/index.js
+var require_spdx_expression_parse = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@3.0.1/node_modules/spdx-expression-parse/index.js"(exports2, module2) {
+    "use strict";
+    var scan = require_scan();
+    var parse = require_parse();
+    module2.exports = function(source) {
+      return parse(scan(source));
+    };
+  }
+});
+
+// node_modules/.pnpm/spdx-correct@3.2.0/node_modules/spdx-correct/index.js
+var require_spdx_correct = __commonJS({
+  "node_modules/.pnpm/spdx-correct@3.2.0/node_modules/spdx-correct/index.js"(exports2, module2) {
+    var parse = require_spdx_expression_parse();
+    var spdxLicenseIds = require_spdx_license_ids();
+    function valid(string) {
+      try {
+        parse(string);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    }
+    __name(valid, "valid");
+    function sortTranspositions(a, b) {
+      var length = b[0].length - a[0].length;
+      if (length !== 0) return length;
+      return a[0].toUpperCase().localeCompare(b[0].toUpperCase());
+    }
+    __name(sortTranspositions, "sortTranspositions");
+    var transpositions = [
+      ["APGL", "AGPL"],
+      ["Gpl", "GPL"],
+      ["GLP", "GPL"],
+      ["APL", "Apache"],
+      ["ISD", "ISC"],
+      ["GLP", "GPL"],
+      ["IST", "ISC"],
+      ["Claude", "Clause"],
+      [" or later", "+"],
+      [" International", ""],
+      ["GNU", "GPL"],
+      ["GUN", "GPL"],
+      ["+", ""],
+      ["GNU GPL", "GPL"],
+      ["GNU LGPL", "LGPL"],
+      ["GNU/GPL", "GPL"],
+      ["GNU GLP", "GPL"],
+      ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL"],
+      ["GNU Lesser General Public License", "LGPL"],
+      ["GNU LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
+      ["GNU Lesser General Public License", "LGPL-2.1"],
+      ["LESSER GENERAL PUBLIC LICENSE", "LGPL"],
+      ["Lesser General Public License", "LGPL"],
+      ["LESSER GENERAL PUBLIC LICENSE", "LGPL-2.1"],
+      ["Lesser General Public License", "LGPL-2.1"],
+      ["GNU General Public License", "GPL"],
+      ["Gnu public license", "GPL"],
+      ["GNU Public License", "GPL"],
+      ["GNU GENERAL PUBLIC LICENSE", "GPL"],
+      ["MTI", "MIT"],
+      ["Mozilla Public License", "MPL"],
+      ["Universal Permissive License", "UPL"],
+      ["WTH", "WTF"],
+      ["WTFGPL", "WTFPL"],
+      ["-License", ""]
+    ].sort(sortTranspositions);
+    var TRANSPOSED = 0;
+    var CORRECT = 1;
+    var transforms = [
+      // e.g. 'mit'
+      function(argument) {
+        return argument.toUpperCase();
+      },
+      // e.g. 'MIT '
+      function(argument) {
+        return argument.trim();
+      },
+      // e.g. 'M.I.T.'
+      function(argument) {
+        return argument.replace(/\./g, "");
+      },
+      // e.g. 'Apache- 2.0'
+      function(argument) {
+        return argument.replace(/\s+/g, "");
+      },
+      // e.g. 'CC BY 4.0''
+      function(argument) {
+        return argument.replace(/\s+/g, "-");
+      },
+      // e.g. 'LGPLv2.1'
+      function(argument) {
+        return argument.replace("v", "-");
+      },
+      // e.g. 'Apache 2.0'
+      function(argument) {
+        return argument.replace(/,?\s*(\d)/, "-$1");
+      },
+      // e.g. 'GPL 2'
+      function(argument) {
+        return argument.replace(/,?\s*(\d)/, "-$1.0");
+      },
+      // e.g. 'Apache Version 2.0'
+      function(argument) {
+        return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, "-$2");
+      },
+      // e.g. 'Apache Version 2'
+      function(argument) {
+        return argument.replace(/,?\s*(V\.|v\.|V|v|Version|version)\s*(\d)/, "-$2.0");
+      },
+      // e.g. 'ZLIB'
+      function(argument) {
+        return argument[0].toUpperCase() + argument.slice(1);
+      },
+      // e.g. 'MPL/2.0'
+      function(argument) {
+        return argument.replace("/", "-");
+      },
+      // e.g. 'Apache 2'
+      function(argument) {
+        return argument.replace(/\s*V\s*(\d)/, "-$1").replace(/(\d)$/, "$1.0");
+      },
+      // e.g. 'GPL-2.0', 'GPL-3.0'
+      function(argument) {
+        if (argument.indexOf("3.0") !== -1) {
+          return argument + "-or-later";
+        } else {
+          return argument + "-only";
+        }
+      },
+      // e.g. 'GPL-2.0-'
+      function(argument) {
+        return argument + "only";
+      },
+      // e.g. 'GPL2'
+      function(argument) {
+        return argument.replace(/(\d)$/, "-$1.0");
+      },
+      // e.g. 'BSD 3'
+      function(argument) {
+        return argument.replace(/(-| )?(\d)$/, "-$2-Clause");
+      },
+      // e.g. 'BSD clause 3'
+      function(argument) {
+        return argument.replace(/(-| )clause(-| )(\d)/, "-$3-Clause");
+      },
+      // e.g. 'New BSD license'
+      function(argument) {
+        return argument.replace(/\b(Modified|New|Revised)(-| )?BSD((-| )License)?/i, "BSD-3-Clause");
+      },
+      // e.g. 'Simplified BSD license'
+      function(argument) {
+        return argument.replace(/\bSimplified(-| )?BSD((-| )License)?/i, "BSD-2-Clause");
+      },
+      // e.g. 'Free BSD license'
+      function(argument) {
+        return argument.replace(/\b(Free|Net)(-| )?BSD((-| )License)?/i, "BSD-2-Clause-$1BSD");
+      },
+      // e.g. 'Clear BSD license'
+      function(argument) {
+        return argument.replace(/\bClear(-| )?BSD((-| )License)?/i, "BSD-3-Clause-Clear");
+      },
+      // e.g. 'Old BSD License'
+      function(argument) {
+        return argument.replace(/\b(Old|Original)(-| )?BSD((-| )License)?/i, "BSD-4-Clause");
+      },
+      // e.g. 'BY-NC-4.0'
+      function(argument) {
+        return "CC-" + argument;
+      },
+      // e.g. 'BY-NC'
+      function(argument) {
+        return "CC-" + argument + "-4.0";
+      },
+      // e.g. 'Attribution-NonCommercial'
+      function(argument) {
+        return argument.replace("Attribution", "BY").replace("NonCommercial", "NC").replace("NoDerivatives", "ND").replace(/ (\d)/, "-$1").replace(/ ?International/, "");
+      },
+      // e.g. 'Attribution-NonCommercial'
+      function(argument) {
+        return "CC-" + argument.replace("Attribution", "BY").replace("NonCommercial", "NC").replace("NoDerivatives", "ND").replace(/ (\d)/, "-$1").replace(/ ?International/, "") + "-4.0";
+      }
+    ];
+    var licensesWithVersions = spdxLicenseIds.map(function(id) {
+      var match = /^(.*)-\d+\.\d+$/.exec(id);
+      return match ? [match[0], match[1]] : [id, null];
+    }).reduce(function(objectMap, item) {
+      var key = item[1];
+      objectMap[key] = objectMap[key] || [];
+      objectMap[key].push(item[0]);
+      return objectMap;
+    }, {});
+    var licensesWithOneVersion = Object.keys(licensesWithVersions).map(/* @__PURE__ */ __name(function makeEntries(key) {
+      return [key, licensesWithVersions[key]];
+    }, "makeEntries")).filter(/* @__PURE__ */ __name(function identifySoleVersions(item) {
+      return (
+        // Licenses has just one valid version suffix.
+        item[1].length === 1 && item[0] !== null && // APL will be considered Apache, rather than APL-1.0
+        item[0] !== "APL"
+      );
+    }, "identifySoleVersions")).map(/* @__PURE__ */ __name(function createLastResorts(item) {
+      return [item[0], item[1][0]];
+    }, "createLastResorts"));
+    licensesWithVersions = void 0;
+    var lastResorts = [
+      ["UNLI", "Unlicense"],
+      ["WTF", "WTFPL"],
+      ["2 CLAUSE", "BSD-2-Clause"],
+      ["2-CLAUSE", "BSD-2-Clause"],
+      ["3 CLAUSE", "BSD-3-Clause"],
+      ["3-CLAUSE", "BSD-3-Clause"],
+      ["AFFERO", "AGPL-3.0-or-later"],
+      ["AGPL", "AGPL-3.0-or-later"],
+      ["APACHE", "Apache-2.0"],
+      ["ARTISTIC", "Artistic-2.0"],
+      ["Affero", "AGPL-3.0-or-later"],
+      ["BEER", "Beerware"],
+      ["BOOST", "BSL-1.0"],
+      ["BSD", "BSD-2-Clause"],
+      ["CDDL", "CDDL-1.1"],
+      ["ECLIPSE", "EPL-1.0"],
+      ["FUCK", "WTFPL"],
+      ["GNU", "GPL-3.0-or-later"],
+      ["LGPL", "LGPL-3.0-or-later"],
+      ["GPLV1", "GPL-1.0-only"],
+      ["GPL-1", "GPL-1.0-only"],
+      ["GPLV2", "GPL-2.0-only"],
+      ["GPL-2", "GPL-2.0-only"],
+      ["GPL", "GPL-3.0-or-later"],
+      ["MIT +NO-FALSE-ATTRIBS", "MITNFA"],
+      ["MIT", "MIT"],
+      ["MPL", "MPL-2.0"],
+      ["X11", "X11"],
+      ["ZLIB", "Zlib"]
+    ].concat(licensesWithOneVersion).sort(sortTranspositions);
+    var SUBSTRING = 0;
+    var IDENTIFIER = 1;
+    var validTransformation = /* @__PURE__ */ __name(function(identifier) {
+      for (var i = 0; i < transforms.length; i++) {
+        var transformed = transforms[i](identifier).trim();
+        if (transformed !== identifier && valid(transformed)) {
+          return transformed;
+        }
+      }
+      return null;
+    }, "validTransformation");
+    var validLastResort = /* @__PURE__ */ __name(function(identifier) {
+      var upperCased = identifier.toUpperCase();
+      for (var i = 0; i < lastResorts.length; i++) {
+        var lastResort = lastResorts[i];
+        if (upperCased.indexOf(lastResort[SUBSTRING]) > -1) {
+          return lastResort[IDENTIFIER];
+        }
+      }
+      return null;
+    }, "validLastResort");
+    var anyCorrection = /* @__PURE__ */ __name(function(identifier, check) {
+      for (var i = 0; i < transpositions.length; i++) {
+        var transposition = transpositions[i];
+        var transposed = transposition[TRANSPOSED];
+        if (identifier.indexOf(transposed) > -1) {
+          var corrected = identifier.replace(
+            transposed,
+            transposition[CORRECT]
+          );
+          var checked = check(corrected);
+          if (checked !== null) {
+            return checked;
+          }
+        }
+      }
+      return null;
+    }, "anyCorrection");
+    module2.exports = function(identifier, options) {
+      options = options || {};
+      var upgrade = options.upgrade === void 0 ? true : !!options.upgrade;
+      function postprocess(value) {
+        return upgrade ? upgradeGPLs(value) : value;
+      }
+      __name(postprocess, "postprocess");
+      var validArugment = typeof identifier === "string" && identifier.trim().length !== 0;
+      if (!validArugment) {
+        throw Error("Invalid argument. Expected non-empty string.");
+      }
+      identifier = identifier.trim();
+      if (valid(identifier)) {
+        return postprocess(identifier);
+      }
+      var noPlus = identifier.replace(/\+$/, "").trim();
+      if (valid(noPlus)) {
+        return postprocess(noPlus);
+      }
+      var transformed = validTransformation(identifier);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = anyCorrection(identifier, function(argument) {
+        if (valid(argument)) {
+          return argument;
+        }
+        return validTransformation(argument);
+      });
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = validLastResort(identifier);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      transformed = anyCorrection(identifier, validLastResort);
+      if (transformed !== null) {
+        return postprocess(transformed);
+      }
+      return null;
+    };
+    function upgradeGPLs(value) {
+      if ([
+        "GPL-1.0",
+        "LGPL-1.0",
+        "AGPL-1.0",
+        "GPL-2.0",
+        "LGPL-2.0",
+        "AGPL-2.0",
+        "LGPL-2.1"
+      ].indexOf(value) !== -1) {
+        return value + "-only";
+      } else if ([
+        "GPL-1.0+",
+        "GPL-2.0+",
+        "GPL-3.0+",
+        "LGPL-2.0+",
+        "LGPL-2.1+",
+        "LGPL-3.0+",
+        "AGPL-1.0+",
+        "AGPL-3.0+"
+      ].indexOf(value) !== -1) {
+        return value.replace(/\+$/, "-or-later");
+      } else if (["GPL-3.0", "LGPL-3.0", "AGPL-3.0"].indexOf(value) !== -1) {
+        return value + "-or-later";
+      } else {
+        return value;
+      }
+    }
+    __name(upgradeGPLs, "upgradeGPLs");
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/scan.js
+var require_scan2 = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/scan.js"(exports2, module2) {
+    "use strict";
+    var licenses = [].concat(require_spdx_license_ids()).concat(require_deprecated());
+    var exceptions = require_spdx_exceptions();
+    module2.exports = function(source) {
+      var index = 0;
+      function hasMore() {
+        return index < source.length;
+      }
+      __name(hasMore, "hasMore");
+      function read(value) {
+        if (value instanceof RegExp) {
+          var chars = source.slice(index);
+          var match = chars.match(value);
+          if (match) {
+            index += match[0].length;
+            return match[0];
+          }
+        } else {
+          if (source.indexOf(value, index) === index) {
+            index += value.length;
+            return value;
+          }
+        }
+      }
+      __name(read, "read");
+      function skipWhitespace() {
+        read(/[ ]*/);
+      }
+      __name(skipWhitespace, "skipWhitespace");
+      function operator() {
+        var string;
+        var possibilities = [/^WITH/i, /^AND/i, /^OR/i, "(", ")", ":", "+"];
+        for (var i = 0; i < possibilities.length; i++) {
+          string = read(possibilities[i]);
+          if (string) {
+            break;
+          }
+        }
+        if (string === "+" && index > 1 && source[index - 2] === " ") {
+          throw new Error("Space before `+`");
+        }
+        return string && {
+          type: "OPERATOR",
+          string: string.toUpperCase()
+        };
+      }
+      __name(operator, "operator");
+      function idstring() {
+        return read(/[A-Za-z0-9-.]+/);
+      }
+      __name(idstring, "idstring");
+      function expectIdstring() {
+        var string = idstring();
+        if (!string) {
+          throw new Error("Expected idstring at offset " + index);
+        }
+        return string;
+      }
+      __name(expectIdstring, "expectIdstring");
+      function documentRef() {
+        if (read("DocumentRef-")) {
+          var string = expectIdstring();
+          return { type: "DOCUMENTREF", string };
+        }
+      }
+      __name(documentRef, "documentRef");
+      function licenseRef() {
+        if (read("LicenseRef-")) {
+          var string = expectIdstring();
+          return { type: "LICENSEREF", string };
+        }
+      }
+      __name(licenseRef, "licenseRef");
+      function identifier() {
+        var begin = index;
+        var string = idstring();
+        if (licenses.indexOf(string) !== -1) {
+          return {
+            type: "LICENSE",
+            string
+          };
+        } else if (exceptions.indexOf(string) !== -1) {
+          return {
+            type: "EXCEPTION",
+            string
+          };
+        }
+        index = begin;
+      }
+      __name(identifier, "identifier");
+      function parseToken() {
+        return operator() || documentRef() || licenseRef() || identifier();
+      }
+      __name(parseToken, "parseToken");
+      var tokens = [];
+      while (hasMore()) {
+        skipWhitespace();
+        if (!hasMore()) {
+          break;
+        }
+        var token = parseToken();
+        if (!token) {
+          throw new Error("Unexpected `" + source[index] + "` at offset " + index);
+        }
+        tokens.push(token);
+      }
+      return tokens;
+    };
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/parse.js
+var require_parse2 = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/parse.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function(tokens) {
+      var index = 0;
+      function hasMore() {
+        return index < tokens.length;
+      }
+      __name(hasMore, "hasMore");
+      function token() {
+        return hasMore() ? tokens[index] : null;
+      }
+      __name(token, "token");
+      function next() {
+        if (!hasMore()) {
+          throw new Error();
+        }
+        index++;
+      }
+      __name(next, "next");
+      function parseOperator(operator) {
+        var t = token();
+        if (t && t.type === "OPERATOR" && operator === t.string) {
+          next();
+          return t.string;
+        }
+      }
+      __name(parseOperator, "parseOperator");
+      function parseWith() {
+        if (parseOperator("WITH")) {
+          var t = token();
+          if (t && t.type === "EXCEPTION") {
+            next();
+            return t.string;
+          }
+          throw new Error("Expected exception after `WITH`");
+        }
+      }
+      __name(parseWith, "parseWith");
+      function parseLicenseRef() {
+        var begin = index;
+        var string = "";
+        var t = token();
+        if (t.type === "DOCUMENTREF") {
+          next();
+          string += "DocumentRef-" + t.string + ":";
+          if (!parseOperator(":")) {
+            throw new Error("Expected `:` after `DocumentRef-...`");
+          }
+        }
+        t = token();
+        if (t.type === "LICENSEREF") {
+          next();
+          string += "LicenseRef-" + t.string;
+          return { license: string };
+        }
+        index = begin;
+      }
+      __name(parseLicenseRef, "parseLicenseRef");
+      function parseLicense() {
+        var t = token();
+        if (t && t.type === "LICENSE") {
+          next();
+          var node2 = { license: t.string };
+          if (parseOperator("+")) {
+            node2.plus = true;
+          }
+          var exception = parseWith();
+          if (exception) {
+            node2.exception = exception;
+          }
+          return node2;
+        }
+      }
+      __name(parseLicense, "parseLicense");
+      function parseParenthesizedExpression() {
+        var left = parseOperator("(");
+        if (!left) {
+          return;
+        }
+        var expr = parseExpression();
+        if (!parseOperator(")")) {
+          throw new Error("Expected `)`");
+        }
+        return expr;
+      }
+      __name(parseParenthesizedExpression, "parseParenthesizedExpression");
+      function parseAtom() {
+        return parseParenthesizedExpression() || parseLicenseRef() || parseLicense();
+      }
+      __name(parseAtom, "parseAtom");
+      function makeBinaryOpParser(operator, nextParser) {
+        return /* @__PURE__ */ __name(function parseBinaryOp() {
+          var left = nextParser();
+          if (!left) {
+            return;
+          }
+          if (!parseOperator(operator)) {
+            return left;
+          }
+          var right = parseBinaryOp();
+          if (!right) {
+            throw new Error("Expected expression");
+          }
+          return {
+            left,
+            conjunction: operator.toLowerCase(),
+            right
+          };
+        }, "parseBinaryOp");
+      }
+      __name(makeBinaryOpParser, "makeBinaryOpParser");
+      var parseAnd = makeBinaryOpParser("AND", parseAtom);
+      var parseExpression = makeBinaryOpParser("OR", parseAnd);
+      var node = parseExpression();
+      if (!node || hasMore()) {
+        throw new Error("Syntax error");
+      }
+      return node;
+    };
+  }
+});
+
+// node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/index.js
+var require_spdx_expression_parse2 = __commonJS({
+  "node_modules/.pnpm/spdx-expression-parse@4.0.0/node_modules/spdx-expression-parse/index.js"(exports2, module2) {
+    "use strict";
+    var scan = require_scan2();
+    var parse = require_parse2();
+    module2.exports = function(source) {
+      return parse(scan(source));
+    };
+  }
+});
+
+// src/external/spdx-pack.js
+var spdxCorrect = require_spdx_correct();
+var spdxExpressionParse = require_spdx_expression_parse2();
+module.exports = {
+  spdxCorrect,
+  spdxExpressionParse
+};