@appland/scanner 1.56.0 → 1.59.0

package/built/rules/circularDependency.js

@@ -1,63 +1,37 @@
 "use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var GraphEdge_1 = __importDefault(require("../algorithms/dataStructures/graph/GraphEdge"));
-var GraphVertex_1 = __importDefault(require("../algorithms/dataStructures/graph/GraphVertex"));
-var Graph_1 = __importDefault(require("../algorithms/dataStructures/graph/Graph"));
-var detect_cycle_1 = __importDefault(require("../algorithms/graph/detect-cycle"));
-var path_1 = require("path");
-var util_1 = require("./lib/util");
-var matchPattern_1 = require("./lib/matchPattern");
-var url_1 = require("url");
-var parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
-var Cycle = /** @class */ (function () {
-    function Cycle(packages, events) {
+const GraphEdge_1 = __importDefault(require("../algorithms/dataStructures/graph/GraphEdge"));
+const GraphVertex_1 = __importDefault(require("../algorithms/dataStructures/graph/GraphVertex"));
+const Graph_1 = __importDefault(require("../algorithms/dataStructures/graph/Graph"));
+const detect_cycle_1 = __importDefault(require("../algorithms/graph/detect-cycle"));
+const path_1 = require("path");
+const util_1 = require("./lib/util");
+const matchPattern_1 = require("./lib/matchPattern");
+const url_1 = require("url");
+const parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
+class Cycle {
+    constructor(packages, events) {
         this.packages = packages;
         this.events = events;
     }
-    return Cycle;
-}());
+}
 function ignorePackage(event, ignoredPackages) {
-    var myPackage = event.codeObject.packageOf;
+    const myPackage = event.codeObject.packageOf;
     return (myPackage === '' ||
-        ignoredPackages.some(function (filter) { return filter(myPackage); }) ||
+        ignoredPackages.some((filter) => filter(myPackage)) ||
         !event.codeObject.location ||
         (0, path_1.isAbsolute)(event.codeObject.location));
 }
 function detectCycles(root, ignoredPackages) {
-    var graph = new Graph_1.default(true);
-    var vertices = new Map();
-    var edges = new Set();
-    var vertexEvents = new Map();
-    var makeVertex = function (pkg, event) {
-        var result = vertices.get(pkg);
+    const graph = new Graph_1.default(true);
+    const vertices = new Map();
+    const edges = new Set();
+    const vertexEvents = new Map();
+    const makeVertex = (pkg, event) => {
+        let result = vertices.get(pkg);
         if (!result) {
             result = new GraphVertex_1.default(pkg);
             vertices.set(pkg, result);
@@ -68,18 +42,18 @@ function detectCycles(root, ignoredPackages) {
         }
         return result;
     };
-    var collectEvent = function (event, parentEvent, parentPackage) {
-        var myPackage = event.codeObject.packageOf;
+    const collectEvent = (event, parentEvent, parentPackage) => {
+        let myPackage = event.codeObject.packageOf;
         if (ignorePackage(event, ignoredPackages)) {
             myPackage = null;
         }
         if (myPackage) {
-            var vertex = makeVertex(myPackage, event);
+            const vertex = makeVertex(myPackage, event);
             if (parentPackage && parentPackage !== myPackage) {
-                var edge = new GraphEdge_1.default(vertices.get(parentPackage), vertex);
+                const edge = new GraphEdge_1.default(vertices.get(parentPackage), vertex);
                 if (!edges.has(edge.getKey())) {
                     if ((0, util_1.verbose)()) {
-                        console.warn("New edge: ".concat(parentPackage, "/").concat(parentEvent, " -> ").concat(myPackage, "/").concat(event));
+                        console.warn(`New edge: ${parentPackage}/${parentEvent} -> ${myPackage}/${event}`);
                     }
                     edges.add(edge.getKey());
                     graph.addEdge(edge);
@@ -87,14 +61,14 @@ function detectCycles(root, ignoredPackages) {
             }
             parentPackage = myPackage;
         }
-        event.children.forEach(function (child) { return collectEvent(child, event, parentPackage); });
+        event.children.forEach((child) => collectEvent(child, event, parentPackage));
     };
     if (root.codeObject.packageOf !== '') {
         makeVertex(root.codeObject.packageOf, root);
     }
     collectEvent(root, null, null);
-    return (0, detect_cycle_1.default)(graph).map(function (cycle) {
-        return new Cycle(cycle.map(function (vertex) { return vertex.getKey(); }), vertexEvents);
+    return (0, detect_cycle_1.default)(graph).map((cycle) => {
+        return new Cycle(cycle.map((vertex) => vertex.getKey()), vertexEvents);
     });
 }
 /**
@@ -103,46 +77,42 @@ function detectCycles(root, ignoredPackages) {
 
  * @returns Sequence of events whose package names match the cyclePath.
  */
-var searchForCycle = function (cycle, ignoredPackages) {
-    var traverseEvent = function (event, recordEvent, cyclePath, cyclePathIndex, path) {
-        if (cyclePathIndex === void 0) { cyclePathIndex = 0; }
-        if (path === void 0) { path = []; }
+const searchForCycle = (cycle, ignoredPackages) => {
+    const traverseEvent = (event, recordEvent, cyclePath, cyclePathIndex = 0, path = []) => {
         if (recordEvent) {
             if ((0, util_1.verbose)()) {
-                console.warn("".concat(Array(path.length).fill('').join('  '), "push: ").concat(event));
+                console.warn(`${Array(path.length).fill('').join('  ')}push: ${event}`);
             }
             path.push(event);
         }
         else {
             if ((0, util_1.verbose)()) {
-                console.warn("".concat(Array(path.length).fill('').join('  '), "traverse: ").concat(event));
+                console.warn(`${Array(path.length).fill('').join('  ')}traverse: ${event}`);
             }
         }
         if (cyclePathIndex === cyclePath.length - 1) {
             if ((0, util_1.verbose)()) {
-                console.warn("".concat(Array(path.length).fill('').join('  '), "result: ").concat(path));
+                console.warn(`${Array(path.length).fill('').join('  ')}result: ${path}`);
             }
-            return __spreadArray([], __read(path), false);
+            return [...path];
         }
-        var myPackage = event.codeObject.packageOf;
+        const myPackage = event.codeObject.packageOf;
         if ((0, util_1.verbose)()) {
-            console.warn(event.children.map(function (child) { return child.codeObject.fqid; }));
+            console.warn(event.children.map((child) => child.codeObject.fqid));
         }
         // Traverse children of ignored or same package
-        var result = event.children
-            .filter(function (child) { return child.codeObject.packageOf === myPackage || ignorePackage(child, ignoredPackages); })
-            .map(function (child) { return traverseEvent(child, false, cyclePath, cyclePathIndex, path); })
+        let result = event.children
+            .filter((child) => child.codeObject.packageOf === myPackage || ignorePackage(child, ignoredPackages))
+            .map((child) => traverseEvent(child, false, cyclePath, cyclePathIndex, path))
             .filter(Boolean);
         // Traverse children of the next package in the graph
         if (result.length === 0) {
             result = event.children
-                .filter(function (child) {
-                return child.codeObject.packageOf !== myPackage &&
-                    !ignorePackage(child, ignoredPackages) &&
-                    cyclePath[cyclePathIndex + 1] === child.codeObject.packageOf;
-            })
-                .map(function (child) { return traverseEvent(child, true, cyclePath, cyclePathIndex + 1, path); })
-                .filter(function (path) { return path; });
+                .filter((child) => child.codeObject.packageOf !== myPackage &&
+                !ignorePackage(child, ignoredPackages) &&
+                cyclePath[cyclePathIndex + 1] === child.codeObject.packageOf)
+                .map((child) => traverseEvent(child, true, cyclePath, cyclePathIndex + 1, path))
+                .filter((path) => path);
         }
         if (result.length > 0) {
             return result[0];
@@ -150,17 +120,17 @@ var searchForCycle = function (cycle, ignoredPackages) {
         else {
             if (recordEvent) {
                 if ((0, util_1.verbose)()) {
-                    console.warn("".concat(Array(path.length - 1)
+                    console.warn(`${Array(path.length - 1)
                         .fill('')
-                        .join('  '), "pop"));
+                        .join('  ')}pop`);
                 }
                 path.pop();
             }
             else {
                 if ((0, util_1.verbose)()) {
-                    console.warn("".concat(Array(path.length - 1)
+                    console.warn(`${Array(path.length - 1)
                         .fill('')
-                        .join('  '), "untraverse"));
+                        .join('  ')}untraverse`);
                 }
             }
             return null;
@@ -168,20 +138,20 @@ var searchForCycle = function (cycle, ignoredPackages) {
     };
     // Look for a cycle starting at each package name. For each package name, consider the
     // events that have that package.
-    for (var i = 0; i < cycle.packages.length; i++) {
-        var packageName = cycle.packages[i];
-        var startEvents = cycle.events.get(packageName);
-        var cyclePath = [];
-        for (var k = 0; k < cycle.packages.length; k++) {
+    for (let i = 0; i < cycle.packages.length; i++) {
+        const packageName = cycle.packages[i];
+        const startEvents = cycle.events.get(packageName);
+        const cyclePath = [];
+        for (let k = 0; k < cycle.packages.length; k++) {
             cyclePath[k] = cycle.packages[(i + k) % cycle.packages.length];
         }
         cyclePath.push(packageName);
         if ((0, util_1.verbose)()) {
-            console.warn("Searching for event path for cycle ".concat(cyclePath));
+            console.warn(`Searching for event path for cycle ${cyclePath}`);
         }
-        for (var j = 0; j < startEvents.length; j++) {
-            var startEvent = startEvents[j];
-            var path = traverseEvent(startEvent, true, cyclePath);
+        for (let j = 0; j < startEvents.length; j++) {
+            const startEvent = startEvents[j];
+            const path = traverseEvent(startEvent, true, cyclePath);
             if (path) {
                 return path;
             }
@@ -189,39 +159,38 @@ var searchForCycle = function (cycle, ignoredPackages) {
     }
     return null;
 };
-var Options = /** @class */ (function () {
-    function Options() {
+class Options {
+    constructor() {
         this.ignoredPackages = [];
         this.depth = 4;
     }
-    return Options;
-}());
+}
 function build(options) {
-    var ignoredPackages = (0, matchPattern_1.buildFilters)(options.ignoredPackages);
+    const ignoredPackages = (0, matchPattern_1.buildFilters)(options.ignoredPackages);
     function matcher(event) {
         return detectCycles(event, ignoredPackages)
-            .filter(function (cycle) { return cycle.packages.length + 1 >= options.depth; })
-            .map(function (cycle) { return searchForCycle(cycle, ignoredPackages); })
-            .filter(function (path) { return path; })
-            .map(function (path) {
+            .filter((cycle) => cycle.packages.length + 1 >= options.depth)
+            .map((cycle) => searchForCycle(cycle, ignoredPackages))
+            .filter((path) => path)
+            .map((path) => {
             return {
                 event: path[0],
                 message: [
                     'Cycle in package dependency graph',
-                    path.map(function (event) { return event.codeObject.packageOf; }).join(' -> '),
+                    path.map((event) => event.codeObject.packageOf).join(' -> '),
                 ].join(': '),
                 relatedEvents: path,
             };
         });
     }
     return {
-        matcher: matcher,
+        matcher,
     };
 }
 exports.default = {
     id: 'circular-dependency',
     title: 'Circular package dependency',
-    Options: Options,
+    Options,
     impactDomain: 'Maintainability',
     references: {
         'CWE-1047': new url_1.URL('https://cwe.mitre.org/data/definitions/1047.html'),
@@ -229,6 +198,5 @@ exports.default = {
     enumerateScope: false,
     description: (0, parseRuleDescription_1.default)('circularDependency'),
     url: 'https://appland.com/docs/analysis/rules-reference.html#circular-dependency',
-    build: build,
+    build,
 };
-//# sourceMappingURL=circularDependency.js.map

package/built/rules/deserializationOfUntrustedData.js

@@ -1,85 +1,52 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var models_1 = require("@appland/models");
-var url_1 = require("url");
-var parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
-var precedingEvents_1 = __importDefault(require("./lib/precedingEvents"));
-var sanitizesData_1 = __importDefault(require("./lib/sanitizesData"));
+const models_1 = require("@appland/models");
+const url_1 = require("url");
+const parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
+const precedingEvents_1 = __importDefault(require("./lib/precedingEvents"));
+const sanitizesData_1 = __importDefault(require("./lib/sanitizesData"));
 function allArgumentsSanitized(rootEvent, event) {
     return (event.parameters || [])
-        .filter(function (parameter) { return parameter.object_id; })
-        .every(function (parameter) {
-        var e_1, _a;
-        try {
-            for (var _b = __values((0, precedingEvents_1.default)(rootEvent, event)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var candidate = _c.value;
-                if ((0, sanitizesData_1.default)(candidate.event, parameter.object_id, DeserializeSanitize)) {
-                    return true;
-                }
+        .filter((parameter) => parameter.object_id)
+        .every((parameter) => {
+        for (const candidate of (0, precedingEvents_1.default)(rootEvent, event)) {
+            if ((0, sanitizesData_1.default)(candidate.event, parameter.object_id, DeserializeSanitize)) {
+                return true;
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         return false;
     });
 }
 function build() {
     function matcher(rootEvent) {
-        var e_2, _a;
-        try {
-            for (var _b = __values(new models_1.EventNavigator(rootEvent).descendants()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var event = _c.value;
-                // events: //*[@authorization && truthy?(returnValue) && not(preceding::*[@authentication]) && not(descendant::*[@authentication])]
-                if (event.event.labels.has(DeserializeUnsafe) &&
-                    !event.event.ancestors().find(function (ancestor) { return ancestor.labels.has(DeserializeSafe); })) {
-                    if (allArgumentsSanitized(rootEvent, event.event)) {
-                        return;
-                    }
-                    else {
-                        return [
-                            {
-                                event: event.event,
-                                message: "".concat(event.event, " deserializes untrusted data"),
-                            },
-                        ];
-                    }
+        for (const event of new models_1.EventNavigator(rootEvent).descendants()) {
+            // events: //*[@authorization && truthy?(returnValue) && not(preceding::*[@authentication]) && not(descendant::*[@authentication])]
+            if (event.event.labels.has(DeserializeUnsafe) &&
+                !event.event.ancestors().find((ancestor) => ancestor.labels.has(DeserializeSafe))) {
+                if (allArgumentsSanitized(rootEvent, event.event)) {
+                    return;
+                }
+                else {
+                    return [
+                        {
+                            event: event.event,
+                            message: `${event.event} deserializes untrusted data`,
+                        },
+                    ];
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
     }
     return {
-        matcher: matcher,
+        matcher,
     };
 }
-var DeserializeUnsafe = 'deserialize.unsafe';
-var DeserializeSafe = 'deserialize.safe';
-var DeserializeSanitize = 'deserialize.sanitize';
+const DeserializeUnsafe = 'deserialize.unsafe';
+const DeserializeSafe = 'deserialize.safe';
+const DeserializeSanitize = 'deserialize.sanitize';
 exports.default = {
     id: 'deserialization-of-untrusted-data',
     title: 'Deserialization of untrusted data',
@@ -92,6 +59,5 @@ exports.default = {
     },
     description: (0, parseRuleDescription_1.default)('deserializationOfUntrustedData'),
     url: 'https://appland.com/docs/analysis/rules-reference.html#deserialization-of-untrusted-data',
-    build: build,
+    build,
 };
-//# sourceMappingURL=deserializationOfUntrustedData.js.map

package/built/rules/execOfUntrustedCommand.js

@@ -1,84 +1,51 @@
 "use strict";
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var models_1 = require("@appland/models");
-var url_1 = require("url");
-var parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
-var precedingEvents_1 = __importDefault(require("./lib/precedingEvents"));
-var sanitizesData_1 = __importDefault(require("./lib/sanitizesData"));
+const models_1 = require("@appland/models");
+const url_1 = require("url");
+const parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
+const precedingEvents_1 = __importDefault(require("./lib/precedingEvents"));
+const sanitizesData_1 = __importDefault(require("./lib/sanitizesData"));
 function allArgumentsSanitized(rootEvent, event) {
     return (event.parameters || [])
-        .filter(function (parameter) { return parameter.object_id; })
-        .every(function (parameter) {
-        var e_1, _a;
-        try {
-            for (var _b = __values((0, precedingEvents_1.default)(rootEvent, event)), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var candidate = _c.value;
-                if ((0, sanitizesData_1.default)(candidate.event, parameter.object_id, ExecSanitize)) {
-                    return true;
-                }
+        .filter((parameter) => parameter.object_id)
+        .every((parameter) => {
+        for (const candidate of (0, precedingEvents_1.default)(rootEvent, event)) {
+            if ((0, sanitizesData_1.default)(candidate.event, parameter.object_id, ExecSanitize)) {
+                return true;
             }
         }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
         return false;
     });
 }
 function build() {
     function matcher(rootEvent) {
-        var e_2, _a;
-        try {
-            for (var _b = __values(new models_1.EventNavigator(rootEvent).descendants()), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var event = _c.value;
-                if (event.event.labels.has(Exec) &&
-                    !event.event.ancestors().find(function (ancestor) { return ancestor.labels.has(ExecSafe); })) {
-                    if (allArgumentsSanitized(rootEvent, event.event)) {
-                        return;
-                    }
-                    else {
-                        return [
-                            {
-                                event: event.event,
-                                message: "".concat(event.event, " executes an untrusted command string"),
-                            },
-                        ];
-                    }
+        for (const event of new models_1.EventNavigator(rootEvent).descendants()) {
+            if (event.event.labels.has(Exec) &&
+                !event.event.ancestors().find((ancestor) => ancestor.labels.has(ExecSafe))) {
+                if (allArgumentsSanitized(rootEvent, event.event)) {
+                    return;
+                }
+                else {
+                    return [
+                        {
+                            event: event.event,
+                            message: `${event.event} executes an untrusted command string`,
+                        },
+                    ];
                 }
             }
         }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
     }
     return {
-        matcher: matcher,
+        matcher,
     };
 }
-var Exec = 'system.exec';
-var ExecSafe = 'system.exec.safe';
-var ExecSanitize = 'system.exec.sanitize';
+const Exec = 'system.exec';
+const ExecSafe = 'system.exec.safe';
+const ExecSanitize = 'system.exec.sanitize';
 exports.default = {
     id: 'exec-of-untrusted-command',
     title: 'Execution of untrusted system command',
@@ -90,6 +57,5 @@ exports.default = {
     },
     description: (0, parseRuleDescription_1.default)('execOfUntrustedCommand'),
     url: 'https://appland.com/docs/analysis/rules-reference.html#exec-of-untrusted-command',
-    build: build,
+    build,
 };
-//# sourceMappingURL=execOfUntrustedCommand.js.map

package/built/rules/http-500/metadata.js

@@ -9,4 +9,3 @@ exports.default = {
         'CWE-392': 'https://cwe.mitre.org/data/definitions/392.html',
     },
 };
-//# sourceMappingURL=metadata.js.map

package/built/rules/http-500/rule.js

@@ -2,9 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 function rule() {
     return {
-        matcher: function (e) { return e.httpServerResponse.status === 500; },
-        where: function (e) { return !!e.httpServerResponse; },
+        matcher: (e) => e.httpServerResponse.status === 500,
+        where: (e) => !!e.httpServerResponse,
     };
 }
 exports.default = rule;
-//# sourceMappingURL=rule.js.map

package/built/rules/illegalPackageDependency.js

@@ -3,40 +3,39 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var matchPattern_1 = require("./lib/matchPattern");
-var url_1 = require("url");
-var parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
-var Options = /** @class */ (function () {
-    function Options() {
+const matchPattern_1 = require("./lib/matchPattern");
+const url_1 = require("url");
+const parseRuleDescription_1 = __importDefault(require("./lib/parseRuleDescription"));
+class Options {
+    constructor() {
         this.callerPackages = [];
         this.calleePackage = {};
     }
-    return Options;
-}());
+}
 function build(options) {
-    var callerPatterns = (0, matchPattern_1.buildFilters)(options.callerPackages || []);
-    var calleePattern = (0, matchPattern_1.buildFilter)(options.calleePackage);
+    const callerPatterns = (0, matchPattern_1.buildFilters)(options.callerPackages || []);
+    const calleePattern = (0, matchPattern_1.buildFilter)(options.calleePackage);
     function where(e) {
         return !!e.parent && !!e.parent.codeObject.packageOf && calleePattern(e.codeObject.packageOf);
     }
     function matcher(e) {
-        var packageNamesStr = options.callerPackages
-            .map(function (config) { return config.equal || config.include || config.match; })
+        const packageNamesStr = options.callerPackages
+            .map((config) => config.equal || config.include || config.match)
             .map(String)
             .join(' or ');
-        var parentPackage = e.parent.codeObject.packageOf;
+        const parentPackage = e.parent.codeObject.packageOf;
         if (!(e.codeObject.packageOf === parentPackage ||
-            callerPatterns.some(function (pattern) { return pattern(parentPackage); }))) {
+            callerPatterns.some((pattern) => pattern(parentPackage)))) {
             return [
                 {
                     event: e,
-                    message: "Code object ".concat(e.codeObject.id, " was invoked from ").concat(parentPackage, ", not from ").concat(packageNamesStr),
+                    message: `Code object ${e.codeObject.id} was invoked from ${parentPackage}, not from ${packageNamesStr}`,
                     relatedEvents: [e.parent],
                 },
             ];
         }
     }
-    return { where: where, matcher: matcher };
+    return { where, matcher };
 }
 exports.default = {
     id: 'illegal-package-dependency',
@@ -51,7 +50,6 @@ exports.default = {
     },
     description: (0, parseRuleDescription_1.default)('illegalPackageDependency'),
     url: 'https://appland.com/docs/analysis/rules-reference.html#illegal-package-dependency',
-    Options: Options,
-    build: build,
+    Options,
+    build,
 };
-//# sourceMappingURL=illegalPackageDependency.js.map