license-cop 1.0.2 → 1.2.0

package/src/lib/spdx/calculate-issues.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "calculateIssues", {
+    enumerable: true,
+    get: ()=>calculateIssues
+});
+const calculateIssues = (license, allowedLicenses)=>{
+    const issues = [];
+    const parseNode = (node)=>{
+        switch(node.type){
+            case "identifier":
+                {
+                    if (!allowedLicenses.includes(node.value)) {
+                        issues.push(node.value);
+                    }
+                    return;
+                }
+            case "AND":
+            case "OR":
+                {
+                    parseNode(node.expressions[0]);
+                    parseNode(node.expressions[1]);
+                    return;
+                }
+            case "WITH":
+                {
+                    if (// TODO: Verify that all exceptions make licenses 'weaker'
+                    !allowedLicenses.includes(node.expressions[0]) || !allowedLicenses.includes(`${node.expressions[0]} WITH ${node.expressions[1]}`)) {
+                        issues.push(`${node.expressions[0]} WITH ${node.expressions[1]}`);
+                    }
+                    return;
+                }
+            default:
+                {
+                    const _exhaustiveCheck = node;
+                    throw new Error(`Unhandled license expression type: ${_exhaustiveCheck}`);
+                }
+        }
+    };
+    parseNode(license);
+    return issues;
+};
+
+//# sourceMappingURL=calculate-issues.js.map

package/src/lib/spdx/calculate-issues.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/calculate-issues.ts"],"sourcesContent":["import { SpdxExpression } from \"./types/spdx-expression\";\n\nexport const calculateIssues = (license: SpdxExpression, allowedLicenses: string[]): string[] => {\n  const issues: string[] = [];\n\n  const parseNode = (node: SpdxExpression): void => {\n    switch (node.type) {\n      case \"identifier\": {\n        if (!allowedLicenses.includes(node.value)) {\n          issues.push(node.value);\n        }\n        return;\n      }\n\n      case \"AND\":\n      case \"OR\": {\n        parseNode(node.expressions[0]);\n        parseNode(node.expressions[1]);\n        return;\n      }\n\n      case \"WITH\": {\n        if (\n          // TODO: Verify that all exceptions make licenses 'weaker'\n          !allowedLicenses.includes(node.expressions[0]) ||\n          !allowedLicenses.includes(`${node.expressions[0]} WITH ${node.expressions[1]}`)\n        ) {\n          issues.push(`${node.expressions[0]} WITH ${node.expressions[1]}`);\n        }\n        return;\n      }\n\n      default: {\n        const _exhaustiveCheck: never = node;\n        throw new Error(`Unhandled license expression type: ${_exhaustiveCheck}`);\n      }\n    }\n  };\n\n  parseNode(license);\n\n  return issues;\n};\n"],"names":["calculateIssues","license","allowedLicenses","issues","parseNode","node","type","includes","value","push","expressions","_exhaustiveCheck","Error"],"mappings":";+BAEaA;;aAAAA;;AAAN,MAAMA,kBAAkB,CAACC,SAAyBC,kBAAwC;IAC/F,MAAMC,SAAmB,EAAE;IAE3B,MAAMC,YAAY,CAACC,OAA+B;QAChD,OAAQA,KAAKC,IAAI;YACf,KAAK;gBAAc;oBACjB,IAAI,CAACJ,gBAAgBK,QAAQ,CAACF,KAAKG,KAAK,GAAG;wBACzCL,OAAOM,IAAI,CAACJ,KAAKG,KAAK;oBACxB,CAAC;oBACD;gBACF;YAEA,KAAK;YACL,KAAK;gBAAM;oBACTJ,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7BN,UAAUC,KAAKK,WAAW,CAAC,EAAE;oBAC7B;gBACF;YAEA,KAAK;gBAAQ;oBACX,IACE,0DAA0D;oBAC1D,CAACR,gBAAgBK,QAAQ,CAACF,KAAKK,WAAW,CAAC,EAAE,KAC7C,CAACR,gBAAgBK,QAAQ,CAAC,CAAC,EAAEF,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC,GAC9E;wBACAP,OAAOM,IAAI,CAAC,CAAC,EAAEJ,KAAKK,WAAW,CAAC,EAAE,CAAC,MAAM,EAAEL,KAAKK,WAAW,CAAC,EAAE,CAAC,CAAC;oBAClE,CAAC;oBACD;gBACF;YAEA;gBAAS;oBACP,MAAMC,mBAA0BN;oBAChC,MAAM,IAAIO,MAAM,CAAC,mCAAmC,EAAED,iBAAiB,CAAC,EAAE;gBAC5E;QACF;IACF;IAEAP,UAAUH;IAEV,OAAOE;AACT"}

package/src/lib/spdx/get-tokens.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "./types/token";
+export declare const getTokens: (input: string) => Token[];

package/src/lib/spdx/get-tokens.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "getTokens", {
+    enumerable: true,
+    get: ()=>getTokens
+});
+const _token = require("./types/token");
+const getTokens = (input)=>{
+    const tokens = [];
+    let currentToken = "";
+    // Pushes the current token to the tokens array and resets the current token
+    const pushToken = ()=>{
+        if (currentToken.length === 0) {
+            return;
+        }
+        if (currentToken === "WITH") {
+            tokens.push({
+                type: "with"
+            });
+        } else if ((0, _token.isOperator)(currentToken)) {
+            tokens.push({
+                type: "operator",
+                value: currentToken
+            });
+        } else {
+            tokens.push({
+                type: "identifier",
+                value: currentToken
+            });
+        }
+        currentToken = "";
+    };
+    for(let i = 0; i < input.length; i++){
+        const currentChar = input[i];
+        if ((0, _token.isParenthesis)(currentChar)) {
+            pushToken();
+            tokens.push({
+                type: "parenthesis",
+                value: currentChar
+            });
+            continue;
+        }
+        if (currentChar === " ") {
+            pushToken();
+            continue;
+        }
+        currentToken += currentChar;
+    }
+    pushToken();
+    return tokens;
+};
+
+//# sourceMappingURL=get-tokens.js.map

package/src/lib/spdx/get-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/get-tokens.ts"],"sourcesContent":["import { isOperator, isParenthesis, Token } from \"./types/token\";\n\nexport const getTokens = (input: string): Token[] => {\n  const tokens: Token[] = [];\n  let currentToken = \"\";\n\n  // Pushes the current token to the tokens array and resets the current token\n  const pushToken = () => {\n    if (currentToken.length === 0) {\n      return;\n    }\n\n    if (currentToken === \"WITH\") {\n      tokens.push({\n        type: \"with\"\n      });\n    } else if (isOperator(currentToken)) {\n      tokens.push({\n        type: \"operator\",\n        value: currentToken\n      });\n    } else {\n      tokens.push({\n        type: \"identifier\",\n        value: currentToken\n      });\n    }\n\n    currentToken = \"\";\n  };\n\n  for (let i = 0; i < input.length; i++) {\n    const currentChar = input[i];\n\n    if (isParenthesis(currentChar)) {\n      pushToken();\n\n      tokens.push({\n        type: \"parenthesis\",\n        value: currentChar\n      });\n\n      continue;\n    }\n\n    if (currentChar === \" \") {\n      pushToken();\n      continue;\n    }\n\n    currentToken += currentChar;\n  }\n\n  pushToken();\n  return tokens;\n};\n"],"names":["getTokens","input","tokens","currentToken","pushToken","length","push","type","isOperator","value","i","currentChar","isParenthesis"],"mappings":";+BAEaA;;aAAAA;;uBAFoC;AAE1C,MAAMA,YAAY,CAACC,QAA2B;IACnD,MAAMC,SAAkB,EAAE;IAC1B,IAAIC,eAAe;IAEnB,4EAA4E;IAC5E,MAAMC,YAAY,IAAM;QACtB,IAAID,aAAaE,MAAM,KAAK,GAAG;YAC7B;QACF,CAAC;QAED,IAAIF,iBAAiB,QAAQ;YAC3BD,OAAOI,IAAI,CAAC;gBACVC,MAAM;YACR;QACF,OAAO,IAAIC,IAAAA,iBAAU,EAACL,eAAe;YACnCD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF,OAAO;YACLD,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAON;YACT;QACF,CAAC;QAEDA,eAAe;IACjB;IAEA,IAAK,IAAIO,IAAI,GAAGA,IAAIT,MAAMI,MAAM,EAAEK,IAAK;QACrC,MAAMC,cAAcV,KAAK,CAACS,EAAE;QAE5B,IAAIE,IAAAA,oBAAa,EAACD,cAAc;YAC9BP;YAEAF,OAAOI,IAAI,CAAC;gBACVC,MAAM;gBACNE,OAAOE;YACT;YAEA,QAAS;QACX,CAAC;QAED,IAAIA,gBAAgB,KAAK;YACvBP;YACA,QAAS;QACX,CAAC;QAEDD,gBAAgBQ;IAClB;IAEAP;IACA,OAAOF;AACT"}

package/src/lib/spdx/parse-license-expression.d.ts

@@ -0,0 +1,2 @@
+import { SpdxExpression, Unlicensed } from "./types/spdx-expression";
+export declare const parseLicenseExpression: (input: string) => SpdxExpression | Unlicensed;

package/src/lib/spdx/parse-license-expression.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "parseLicenseExpression", {
+    enumerable: true,
+    get: ()=>parseLicenseExpression
+});
+const _getTokens = require("./get-tokens");
+const _parseTokens = require("./parse-tokens");
+const parseLicenseExpression = (input)=>{
+    if (input === "UNLICENSED") {
+        return {
+            type: "unlicensed"
+        };
+    }
+    const tokens = (0, _getTokens.getTokens)(input);
+    return (0, _parseTokens.parseTokens)(tokens, input);
+};
+
+//# sourceMappingURL=parse-license-expression.js.map

package/src/lib/spdx/parse-license-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-license-expression.ts"],"sourcesContent":["import { getTokens } from \"./get-tokens\";\nimport { parseTokens } from \"./parse-tokens\";\nimport { SpdxExpression, Unlicensed } from \"./types/spdx-expression\";\n\nexport const parseLicenseExpression = (input: string): SpdxExpression | Unlicensed => {\n  if (input === \"UNLICENSED\") {\n    return {\n      type: \"unlicensed\"\n    };\n  }\n\n  const tokens = getTokens(input);\n  return parseTokens(tokens, input);\n};\n"],"names":["parseLicenseExpression","input","type","tokens","getTokens","parseTokens"],"mappings":";+BAIaA;;aAAAA;;2BAJa;6BACE;AAGrB,MAAMA,yBAAyB,CAACC,QAA+C;IACpF,IAAIA,UAAU,cAAc;QAC1B,OAAO;YACLC,MAAM;QACR;IACF,CAAC;IAED,MAAMC,SAASC,IAAAA,oBAAS,EAACH;IACzB,OAAOI,IAAAA,wBAAW,EAACF,QAAQF;AAC7B"}

package/src/lib/spdx/parse-tokens.d.ts

@@ -0,0 +1,3 @@
+import { SpdxExpression } from "./types/spdx-expression";
+import { Token } from "./types/token";
+export declare const parseTokens: (tokens: Token[], originalInput: string) => SpdxExpression;

package/src/lib/spdx/parse-tokens.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "parseTokens", {
+    enumerable: true,
+    get: ()=>parseTokens
+});
+const parseTokens = (tokens, originalInput)=>{
+    let index = 0;
+    const throwNotValid = ()=>{
+        throw new Error(`'${originalInput}' is not a valid SPDX expression`);
+    };
+    const hasMore = ()=>index < tokens.length;
+    const getCurrentToken = ()=>hasMore() ? tokens[index] : null;
+    const moveToNextToken = ()=>{
+        if (!hasMore()) {
+            throwNotValid();
+        }
+        index++;
+    };
+    const tryParseParenthesis = (operator)=>{
+        const currentToken = getCurrentToken();
+        if (currentToken && currentToken.type === "parenthesis" && operator === currentToken.value) {
+            moveToNextToken();
+            return true;
+        }
+        return false;
+    };
+    const tryParseWithToken = ()=>{
+        const currentToken = getCurrentToken();
+        if (currentToken && currentToken.type === "with") {
+            moveToNextToken();
+            return true;
+        }
+        return false;
+    };
+    const tryParseOperator = (operator)=>{
+        const currentToken = getCurrentToken();
+        if (currentToken && currentToken.type === "operator" && operator === currentToken.value) {
+            moveToNextToken();
+            return currentToken.value;
+        }
+        return undefined;
+    };
+    const tryParseLicense = ()=>{
+        const currentToken = getCurrentToken();
+        if (currentToken && currentToken.type === "identifier") {
+            moveToNextToken();
+            return {
+                type: "identifier",
+                value: currentToken.value
+            };
+        }
+        return undefined;
+    };
+    const tryParseParenthesizedExpression = ()=>{
+        const startsWithParenthesis = tryParseParenthesis("(");
+        if (!startsWithParenthesis) {
+            return undefined;
+        }
+        const innerExpression = tryParseExpression();
+        const endsWithParenthesis = tryParseParenthesis(")");
+        if (!endsWithParenthesis) {
+            throwNotValid();
+        }
+        return innerExpression;
+    };
+    const binaryOperationFactory = (operator, tryNextParser)=>{
+        const tryParseBinaryOperation = ()=>{
+            const left = tryNextParser();
+            if (!left) {
+                return undefined;
+            }
+            if (!tryParseOperator(operator)) {
+                return left;
+            }
+            const right = tryParseBinaryOperation();
+            if (!right) {
+                return throwNotValid();
+            }
+            return {
+                type: operator,
+                expressions: [
+                    left,
+                    right
+                ]
+            };
+        };
+        return tryParseBinaryOperation;
+    };
+    const tryParseWith = ()=>{
+        const left = tryParseLicense();
+        if (!left) {
+            return undefined;
+        }
+        if (!tryParseWithToken()) {
+            return left;
+        }
+        const right = tryParseLicense();
+        if (!right) {
+            return throwNotValid();
+        }
+        return {
+            type: "WITH",
+            expressions: [
+                left.value,
+                right.value
+            ]
+        };
+    };
+    const parseAnd = binaryOperationFactory("AND", ()=>tryParseParenthesizedExpression() || tryParseWith());
+    const tryParseExpression = binaryOperationFactory("OR", parseAnd);
+    const node = tryParseExpression();
+    if (!node || hasMore()) {
+        return throwNotValid();
+    }
+    return node;
+};
+
+//# sourceMappingURL=parse-tokens.js.map

package/src/lib/spdx/parse-tokens.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/spdx/parse-tokens.ts"],"sourcesContent":["import { Identifier, SpdxExpression } from \"./types/spdx-expression\";\nimport { Token, Parenthesis, Operator } from \"./types/token\";\n\nexport const parseTokens = (tokens: Token[], originalInput: string): SpdxExpression => {\n  let index = 0;\n\n  const throwNotValid = () => {\n    throw new Error(`'${originalInput}' is not a valid SPDX expression`);\n  };\n\n  const hasMore = (): boolean => index < tokens.length;\n\n  const getCurrentToken = (): Token | null => (hasMore() ? tokens[index] : null);\n\n  const moveToNextToken = () => {\n    if (!hasMore()) {\n      throwNotValid();\n    }\n\n    index++;\n  };\n\n  const tryParseParenthesis = (operator: Parenthesis): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"parenthesis\" && operator === currentToken.value) {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseWithToken = (): boolean => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"with\") {\n      moveToNextToken();\n      return true;\n    }\n\n    return false;\n  };\n\n  const tryParseOperator = (operator: Operator): Operator | undefined => {\n    const currentToken = getCurrentToken();\n\n    if (currentToken && currentToken.type === \"operator\" && operator === currentToken.value) {\n      moveToNextToken();\n      return currentToken.value;\n    }\n\n    return undefined;\n  };\n\n  const tryParseLicense = (): Identifier | undefined => {\n    const currentToken = getCurrentToken();\n    if (currentToken && currentToken.type === \"identifier\") {\n      moveToNextToken();\n\n      return {\n        type: \"identifier\",\n        value: currentToken.value\n      };\n    }\n\n    return undefined;\n  };\n\n  const tryParseParenthesizedExpression = () => {\n    const startsWithParenthesis = tryParseParenthesis(\"(\");\n    if (!startsWithParenthesis) {\n      return undefined;\n    }\n\n    const innerExpression = tryParseExpression();\n\n    const endsWithParenthesis = tryParseParenthesis(\")\");\n    if (!endsWithParenthesis) {\n      throwNotValid();\n    }\n\n    return innerExpression;\n  };\n\n  const binaryOperationFactory = (\n    operator: Exclude<Operator, \"WITH\">,\n    tryNextParser: () => SpdxExpression | undefined\n  ) => {\n    const tryParseBinaryOperation = (): SpdxExpression | undefined => {\n      const left = tryNextParser();\n\n      if (!left) {\n        return undefined;\n      }\n\n      if (!tryParseOperator(operator)) {\n        return left;\n      }\n\n      const right = tryParseBinaryOperation();\n      if (!right) {\n        return throwNotValid();\n      }\n\n      return {\n        type: operator,\n        expressions: [left, right]\n      };\n    };\n\n    return tryParseBinaryOperation;\n  };\n\n  const tryParseWith = (): SpdxExpression | undefined => {\n    const left = tryParseLicense();\n\n    if (!left) {\n      return undefined;\n    }\n\n    if (!tryParseWithToken()) {\n      return left;\n    }\n\n    const right = tryParseLicense();\n    if (!right) {\n      return throwNotValid();\n    }\n\n    return {\n      type: \"WITH\",\n      expressions: [left.value, right.value]\n    };\n  };\n\n  const parseAnd = binaryOperationFactory(\n    \"AND\",\n    () => tryParseParenthesizedExpression() || tryParseWith()\n  );\n  const tryParseExpression = binaryOperationFactory(\"OR\", parseAnd);\n\n  const node = tryParseExpression();\n  if (!node || hasMore()) {\n    return throwNotValid();\n  }\n\n  return node;\n};\n"],"names":["parseTokens","tokens","originalInput","index","throwNotValid","Error","hasMore","length","getCurrentToken","moveToNextToken","tryParseParenthesis","operator","currentToken","type","value","tryParseWithToken","tryParseOperator","undefined","tryParseLicense","tryParseParenthesizedExpression","startsWithParenthesis","innerExpression","tryParseExpression","endsWithParenthesis","binaryOperationFactory","tryNextParser","tryParseBinaryOperation","left","right","expressions","tryParseWith","parseAnd","node"],"mappings":";+BAGaA;;aAAAA;;AAAN,MAAMA,cAAc,CAACC,QAAiBC,gBAA0C;IACrF,IAAIC,QAAQ;IAEZ,MAAMC,gBAAgB,IAAM;QAC1B,MAAM,IAAIC,MAAM,CAAC,CAAC,EAAEH,cAAc,gCAAgC,CAAC,EAAE;IACvE;IAEA,MAAMI,UAAU,IAAeH,QAAQF,OAAOM,MAAM;IAEpD,MAAMC,kBAAkB,IAAqBF,YAAYL,MAAM,CAACE,MAAM,GAAG,IAAI;IAE7E,MAAMM,kBAAkB,IAAM;QAC5B,IAAI,CAACH,WAAW;YACdF;QACF,CAAC;QAEDD;IACF;IAEA,MAAMO,sBAAsB,CAACC,WAAmC;QAC9D,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,iBAAiBF,aAAaC,aAAaE,KAAK,EAAE;YAC1FL;YACA,OAAO,IAAI;QACb,CAAC;QAED,OAAO,KAAK;IACd;IAEA,MAAMM,oBAAoB,IAAe;QACvC,MAAMH,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,QAAQ;YAChDJ;YACA,OAAO,IAAI;QACb,CAAC;QAED,OAAO,KAAK;IACd;IAEA,MAAMO,mBAAmB,CAACL,WAA6C;QACrE,MAAMC,eAAeJ;QAErB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAcF,aAAaC,aAAaE,KAAK,EAAE;YACvFL;YACA,OAAOG,aAAaE,KAAK;QAC3B,CAAC;QAED,OAAOG;IACT;IAEA,MAAMC,kBAAkB,IAA8B;QACpD,MAAMN,eAAeJ;QACrB,IAAII,gBAAgBA,aAAaC,IAAI,KAAK,cAAc;YACtDJ;YAEA,OAAO;gBACLI,MAAM;gBACNC,OAAOF,aAAaE,KAAK;YAC3B;QACF,CAAC;QAED,OAAOG;IACT;IAEA,MAAME,kCAAkC,IAAM;QAC5C,MAAMC,wBAAwBV,oBAAoB;QAClD,IAAI,CAACU,uBAAuB;YAC1B,OAAOH;QACT,CAAC;QAED,MAAMI,kBAAkBC;QAExB,MAAMC,sBAAsBb,oBAAoB;QAChD,IAAI,CAACa,qBAAqB;YACxBnB;QACF,CAAC;QAED,OAAOiB;IACT;IAEA,MAAMG,yBAAyB,CAC7Bb,UACAc,gBACG;QACH,MAAMC,0BAA0B,IAAkC;YAChE,MAAMC,OAAOF;YAEb,IAAI,CAACE,MAAM;gBACT,OAAOV;YACT,CAAC;YAED,IAAI,CAACD,iBAAiBL,WAAW;gBAC/B,OAAOgB;YACT,CAAC;YAED,MAAMC,QAAQF;YACd,IAAI,CAACE,OAAO;gBACV,OAAOxB;YACT,CAAC;YAED,OAAO;gBACLS,MAAMF;gBACNkB,aAAa;oBAACF;oBAAMC;iBAAM;YAC5B;QACF;QAEA,OAAOF;IACT;IAEA,MAAMI,eAAe,IAAkC;QACrD,MAAMH,OAAOT;QAEb,IAAI,CAACS,MAAM;YACT,OAAOV;QACT,CAAC;QAED,IAAI,CAACF,qBAAqB;YACxB,OAAOY;QACT,CAAC;QAED,MAAMC,QAAQV;QACd,IAAI,CAACU,OAAO;YACV,OAAOxB;QACT,CAAC;QAED,OAAO;YACLS,MAAM;YACNgB,aAAa;gBAACF,KAAKb,KAAK;gBAAEc,MAAMd,KAAK;aAAC;QACxC;IACF;IAEA,MAAMiB,WAAWP,uBACf,OACA,IAAML,qCAAqCW;IAE7C,MAAMR,qBAAqBE,uBAAuB,MAAMO;IAExD,MAAMC,OAAOV;IACb,IAAI,CAACU,QAAQ1B,WAAW;QACtB,OAAOF;IACT,CAAC;IAED,OAAO4B;AACT"}

package/src/lib/spdx/types/spdx-expression.d.ts

@@ -0,0 +1,20 @@
+export type Identifier = {
+    type: "identifier";
+    value: string;
+};
+export type AndExpression = {
+    type: "AND";
+    expressions: [SpdxExpression, SpdxExpression];
+};
+export type OrExpression = {
+    type: "OR";
+    expressions: [SpdxExpression, SpdxExpression];
+};
+export type WithExpression = {
+    type: "WITH";
+    expressions: [string, string];
+};
+export type SpdxExpression = Identifier | AndExpression | OrExpression | WithExpression;
+export type Unlicensed = {
+    type: "unlicensed";
+};

package/src/lib/spdx/types/spdx-expression.js

@@ -0,0 +1,3 @@
+"use strict";
+
+//# sourceMappingURL=spdx-expression.js.map

package/src/lib/spdx/types/spdx-expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/spdx-expression.ts"],"names":[],"mappings":""}

package/src/lib/spdx/types/token.d.ts

@@ -0,0 +1,23 @@
+declare const operators: readonly ["AND", "OR"];
+export declare const isOperator: (value: string) => value is "AND" | "OR";
+export type Operator = (typeof operators)[number];
+export type OperatorToken = {
+    type: "operator";
+    value: Operator;
+};
+export type WithToken = {
+    type: "with";
+};
+export type IdentifierToken = {
+    type: "identifier";
+    value: string;
+};
+declare const parenthesis: readonly ["(", ")"];
+export declare const isParenthesis: (value: string) => value is "(" | ")";
+export type Parenthesis = (typeof parenthesis)[number];
+export type ParenthesisToken = {
+    type: "parenthesis";
+    value: Parenthesis;
+};
+export type Token = OperatorToken | WithToken | IdentifierToken | ParenthesisToken;
+export {};

package/src/lib/spdx/types/token.js

@@ -0,0 +1,25 @@
+// Operators
+"use strict";
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    isOperator: ()=>isOperator,
+    isParenthesis: ()=>isParenthesis
+});
+const operators = [
+    "AND",
+    "OR"
+];
+const isOperator = (value)=>operators.includes(value);
+// Parenthesis
+const parenthesis = [
+    "(",
+    ")"
+];
+const isParenthesis = (value)=>parenthesis.includes(value);
+
+//# sourceMappingURL=token.js.map

package/src/lib/spdx/types/token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../packages/license-cop/src/lib/spdx/types/token.ts"],"sourcesContent":["// Operators\n\nconst operators = [\"AND\", \"OR\"] as const;\nexport const isOperator = (value: string): value is Operator =>\n  operators.includes(value as Operator);\n\nexport type Operator = (typeof operators)[number];\nexport type OperatorToken = {\n  type: \"operator\";\n  value: Operator;\n};\n\n// With\n\nexport type WithToken = {\n  type: \"with\";\n};\n\n// Identifiers\n\nexport type IdentifierToken = {\n  type: \"identifier\";\n  value: string;\n};\n\n// Parenthesis\n\nconst parenthesis = [\"(\", \")\"] as const;\nexport const isParenthesis = (value: string): value is Parenthesis =>\n  parenthesis.includes(value as Parenthesis);\n\nexport type Parenthesis = (typeof parenthesis)[number];\nexport type ParenthesisToken = {\n  type: \"parenthesis\";\n  value: Parenthesis;\n};\n\nexport type Token = OperatorToken | WithToken | IdentifierToken | ParenthesisToken;\n"],"names":["isOperator","isParenthesis","operators","value","includes","parenthesis"],"mappings":"AAAA,YAAY;;;;;;;;;IAGCA,UAAU,MAAVA;IAyBAC,aAAa,MAAbA;;AA1Bb,MAAMC,YAAY;IAAC;IAAO;CAAK;AACxB,MAAMF,aAAa,CAACG,QACzBD,UAAUE,QAAQ,CAACD;AAqBrB,cAAc;AAEd,MAAME,cAAc;IAAC;IAAK;CAAI;AACvB,MAAMJ,gBAAgB,CAACE,QAC5BE,YAAYD,QAAQ,CAACD"}

package/src/lib/utils/join-string-array.d.ts

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

package/src/lib/utils/join-string-array.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "joinStringArray", {
+    enumerable: true,
+    get: ()=>joinStringArray
+});
+const joinStringArray = (array)=>{
+    let result = "";
+    for(let i = 0; i < array.length; i++){
+        result += array[i];
+        const isPenultimateElement = i === array.length - 2;
+        const isLastElement = i === array.length - 1;
+        if (isPenultimateElement) {
+            if (array.length === 2) {
+                result += " and ";
+            } else {
+                result += ", and ";
+            }
+        }
+        if (!isLastElement && !isPenultimateElement) {
+            result += ", ";
+        }
+    }
+    return result;
+};
+
+//# sourceMappingURL=join-string-array.js.map

package/src/lib/utils/join-string-array.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/utils/join-string-array.ts"],"sourcesContent":["export const joinStringArray = (array: string[]): string => {\n  let result = \"\";\n\n  for (let i = 0; i < array.length; i++) {\n    result += array[i];\n\n    const isPenultimateElement = i === array.length - 2;\n    const isLastElement = i === array.length - 1;\n\n    if (isPenultimateElement) {\n      if (array.length === 2) {\n        result += \" and \";\n      } else {\n        result += \", and \";\n      }\n    }\n\n    if (!isLastElement && !isPenultimateElement) {\n      result += \", \";\n    }\n  }\n\n  return result;\n};\n"],"names":["joinStringArray","array","result","i","length","isPenultimateElement","isLastElement"],"mappings":";+BAAaA;;aAAAA;;AAAN,MAAMA,kBAAkB,CAACC,QAA4B;IAC1D,IAAIC,SAAS;IAEb,IAAK,IAAIC,IAAI,GAAGA,IAAIF,MAAMG,MAAM,EAAED,IAAK;QACrCD,UAAUD,KAAK,CAACE,EAAE;QAElB,MAAME,uBAAuBF,MAAMF,MAAMG,MAAM,GAAG;QAClD,MAAME,gBAAgBH,MAAMF,MAAMG,MAAM,GAAG;QAE3C,IAAIC,sBAAsB;YACxB,IAAIJ,MAAMG,MAAM,KAAK,GAAG;gBACtBF,UAAU;YACZ,OAAO;gBACLA,UAAU;YACZ,CAAC;QACH,CAAC;QAED,IAAI,CAACI,iBAAiB,CAACD,sBAAsB;YAC3CH,UAAU;QACZ,CAAC;IACH;IAEA,OAAOA;AACT"}

package/src/lib/cli/arguments.d.ts

@@ -1,18 +0,0 @@
-import { Spec } from "arg";
-export interface UserInputs {
-    version?: boolean;
-}
-export interface ArgumentsWithAliases extends Spec {
-    "--init": typeof Boolean;
-    "--directory": typeof String;
-    "--dir": "--directory";
-    "-d": "--directory";
-    "--include-dev-dependencies": typeof Boolean;
-    "--dev": "--include-dev-dependencies";
-    "-D": "--include-dev-dependencies";
-    "--dev-dependencies-only": typeof Boolean;
-    "--dev-only": "--dev-dependencies-only";
-    "--version": typeof Boolean;
-    "-v": "--version";
-}
-export declare const argumentsWithAliases: ArgumentsWithAliases;

package/src/lib/cli/arguments.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "argumentsWithAliases", {
-    enumerable: true,
-    get: ()=>argumentsWithAliases
-});
-const argumentsWithAliases = {
-    "--init": Boolean,
-    "--directory": String,
-    "--dir": "--directory",
-    "-d": "--directory",
-    "--include-dev-dependencies": Boolean,
-    "--dev": "--include-dev-dependencies",
-    "-D": "--include-dev-dependencies",
-    "--dev-dependencies-only": Boolean,
-    "--dev-only": "--dev-dependencies-only",
-    "--version": Boolean,
-    "-v": "--version"
-};
-
-//# sourceMappingURL=arguments.js.map

package/src/lib/cli/arguments.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/arguments.ts"],"sourcesContent":["import { Spec } from \"arg\";\n\nexport interface UserInputs {\n  version?: boolean;\n}\n\nexport interface ArgumentsWithAliases extends Spec {\n  \"--init\": typeof Boolean;\n\n  \"--directory\": typeof String;\n  \"--dir\": \"--directory\";\n  \"-d\": \"--directory\";\n\n  \"--include-dev-dependencies\": typeof Boolean;\n  \"--dev\": \"--include-dev-dependencies\";\n  \"-D\": \"--include-dev-dependencies\";\n\n  \"--dev-dependencies-only\": typeof Boolean;\n  \"--dev-only\": \"--dev-dependencies-only\";\n\n  \"--version\": typeof Boolean;\n  \"-v\": \"--version\";\n}\n\nexport const argumentsWithAliases: ArgumentsWithAliases = {\n  \"--init\": Boolean,\n\n  \"--directory\": String,\n  \"--dir\": \"--directory\",\n  \"-d\": \"--directory\",\n\n  \"--include-dev-dependencies\": Boolean,\n  \"--dev\": \"--include-dev-dependencies\",\n  \"-D\": \"--include-dev-dependencies\",\n\n  \"--dev-dependencies-only\": Boolean,\n  \"--dev-only\": \"--dev-dependencies-only\",\n\n  \"--version\": Boolean,\n  \"-v\": \"--version\"\n};\n"],"names":["argumentsWithAliases","Boolean","String"],"mappings":";;;;+BAwBaA;;aAAAA;;AAAN,MAAMA,uBAA6C;IACxD,UAAUC;IAEV,eAAeC;IACf,SAAS;IACT,MAAM;IAEN,8BAA8BD;IAC9B,SAAS;IACT,MAAM;IAEN,2BAA2BA;IAC3B,cAAc;IAEd,aAAaA;IACb,MAAM;AACR"}

package/src/lib/cli/init.d.ts

@@ -1 +0,0 @@
-export declare const init: (rootDir: string) => Promise<void>;

package/src/lib/cli/init.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "init", {
-    enumerable: true,
-    get: ()=>init
-});
-const _promises = require("fs/promises");
-const _path = require("path");
-const defaultConfig = `{
-  "licenses": ["MIT", "ISC", "Apache-2.0"],
-  "packages": []
-}
-`;
-const init = async (rootDir)=>{
-    console.log("Setting up a new license-cop config file...");
-    const configPath = (0, _path.join)(rootDir, ".licenses.json");
-    (0, _promises.writeFile)(configPath, defaultConfig);
-    console.log("Done!");
-    console.log("Run `npx license-cop` to check your dependencies");
-};
-
-//# sourceMappingURL=init.js.map

package/src/lib/cli/init.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/init.ts"],"sourcesContent":["import { writeFile } from \"fs/promises\";\nimport { join } from \"path\";\n\nconst defaultConfig = `{\n  \"licenses\": [\"MIT\", \"ISC\", \"Apache-2.0\"],\n  \"packages\": []\n}\n`;\n\nexport const init = async (rootDir: string) => {\n  console.log(\"Setting up a new license-cop config file...\");\n\n  const configPath = join(rootDir, \".licenses.json\");\n  writeFile(configPath, defaultConfig);\n\n  console.log(\"Done!\");\n  console.log(\"Run `npx license-cop` to check your dependencies\");\n};\n"],"names":["init","defaultConfig","rootDir","console","log","configPath","join","writeFile"],"mappings":";;;;+BASaA;;aAAAA;;0BATa;sBACL;AAErB,MAAMC,gBAAgB,CAAC;;;;AAIvB,CAAC;AAEM,MAAMD,OAAO,OAAOE,UAAoB;IAC7CC,QAAQC,GAAG,CAAC;IAEZ,MAAMC,aAAaC,IAAAA,UAAI,EAACJ,SAAS;IACjCK,IAAAA,mBAAS,EAACF,YAAYJ;IAEtBE,QAAQC,GAAG,CAAC;IACZD,QAAQC,GAAG,CAAC;AACd"}

package/src/lib/cli/version.d.ts

@@ -1 +0,0 @@
-export declare const printPackageVersion: () => Promise<void>;

package/src/lib/cli/version.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "printPackageVersion", {
-    enumerable: true,
-    get: ()=>printPackageVersion
-});
-const _path = require("path");
-const _packageJson = require("../package-json");
-const printPackageVersion = async ()=>{
-    const packageJsonLocation = (0, _path.join)(__dirname, "../../../package.json");
-    const { version  } = await (0, _packageJson.readPackageJson)(packageJsonLocation);
-    console.log(`v${version}`);
-};
-
-//# sourceMappingURL=version.js.map

package/src/lib/cli/version.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../../packages/license-cop/src/lib/cli/version.ts"],"sourcesContent":["import { join } from \"path\";\nimport { readPackageJson } from \"../package-json\";\n\nexport const printPackageVersion = async (): Promise<void> => {\n  const packageJsonLocation = join(__dirname, \"../../../package.json\");\n  const { version } = await readPackageJson(packageJsonLocation);\n  console.log(`v${version}`);\n};\n"],"names":["printPackageVersion","packageJsonLocation","join","__dirname","version","readPackageJson","console","log"],"mappings":";;;;+BAGaA;;aAAAA;;sBAHQ;6BACW;AAEzB,MAAMA,sBAAsB,UAA2B;IAC5D,MAAMC,sBAAsBC,IAAAA,UAAI,EAACC,WAAW;IAC5C,MAAM,EAAEC,QAAO,EAAE,GAAG,MAAMC,IAAAA,4BAAe,EAACJ;IAC1CK,QAAQC,GAAG,CAAC,CAAC,CAAC,EAAEH,QAAQ,CAAC;AAC3B"}

package/src/lib/violations-error.d.ts

@@ -1,9 +0,0 @@
-export declare class ViolationsError extends Error {
-    readonly violations: Set<Violation>;
-    constructor(violations: Set<Violation>);
-}
-export interface Violation {
-    packageName: string;
-    packageVersion: string;
-    license: string;
-}

package/src/lib/violations-error.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "ViolationsError", {
-    enumerable: true,
-    get: ()=>ViolationsError
-});
-let ViolationsError = class ViolationsError extends Error {
-    constructor(violations){
-        super();
-        this.violations = violations;
-    }
-};
-
-//# sourceMappingURL=violations-error.js.map

package/src/lib/violations-error.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../../packages/license-cop/src/lib/violations-error.ts"],"sourcesContent":["export class ViolationsError extends Error {\n  constructor(public readonly violations: Set<Violation>) {\n    super();\n  }\n}\n\nexport interface Violation {\n  packageName: string;\n  packageVersion: string;\n  license: string;\n}\n"],"names":["ViolationsError","Error","constructor","violations"],"mappings":";;;;+BAAaA;;aAAAA;;AAAN,IAAA,AAAMA,kBAAN,MAAMA,wBAAwBC;IACnCC,YAA4BC,WAA4B;QACtD,KAAK;0BADqBA;IAE5B;AACF"}