@fabasoad/sarif-to-slack 1.3.4 → 1.4.0

package/src/processors/ProcessorFactory.ts

@@ -1,8 +1,8 @@
-import { CommonProcessor } from './CommonProcessor'
-import type { Result, Run, ToolComponent } from 'sarif'
-import { findToolComponent } from '../utils/SarifUtils'
-import { SnykProcessor } from './SnykProcessor'
-import { CodeQLProcessor } from './CodeQLProcessor'
+import { CommonProcessor } from './CommonProcessor';
+import type { Result, Run, ToolComponent } from 'sarif';
+import { findToolComponent } from '../utils/SarifUtils';
+import { SnykProcessor } from './SnykProcessor';
+import { CodeQLProcessor } from './CodeQLProcessor';
 
 /**
  * Creates a new instance of {@link CommonProcessor} class. It tries to find specific
@@ -14,10 +14,10 @@ import { CodeQLProcessor } from './CodeQLProcessor'
  * @internal
  */
 export function createProcessor(run: Run, result: Result): CommonProcessor {
-  const toolComponent: ToolComponent = findToolComponent(run, result)
+  const toolComponent: ToolComponent = findToolComponent(run, result);
   switch (toolComponent.name) {
-    case 'CodeQL': return new CodeQLProcessor(run, result)
-    case 'Snyk Open Source': return new SnykProcessor(run, result)
-    default: return new CommonProcessor(run, result)
+    case 'CodeQL': return new CodeQLProcessor(run, result);
+    case 'Snyk Open Source': return new SnykProcessor(run, result);
+    default: return new CommonProcessor(run, result);
   }
 }

package/src/processors/SnykProcessor.ts

@@ -1,4 +1,4 @@
-import { CommonProcessor } from './CommonProcessor'
+import { CommonProcessor } from './CommonProcessor';
 
 /**
  * This class has extra logic for processing SARIF files produced by Snyk Open
@@ -12,8 +12,9 @@ export class SnykProcessor extends CommonProcessor {
    * property where CVSS score is also defined. This method tries to get level
    * from this "cvssv3_baseScore" property and if it fails to do so, then it tries
    * to get CVSS score in a common way.
+   * @internal
    */
   public override tryFindCvssScore(): number | undefined {
-    return this.tryFindRuleProperty<number>('cvssv3_baseScore') ?? super.tryFindCvssScore()
+    return this.tryFindRuleProperty<number>('cvssv3_baseScore') ?? super.tryFindCvssScore();
   }
 }

package/src/representations/CompactGroupByRepresentation.ts

@@ -1,9 +1,9 @@
-import Representation from './Representation'
-import type Finding from '../model/Finding'
-import { findingsComparatorByKey } from '../utils/Comparators'
-import { SecurityLevel, SecuritySeverity } from '../types'
+import Representation from './Representation';
+import type Finding from '../model/Finding';
+import { findingsComparatorByKey } from '../utils/Comparators';
+import { SecurityLevel, SecuritySeverity } from '../types';
 
-const NO_VULNS_FOUND_TEXT = 'No vulnerabilities found'
+const NO_VULNS_FOUND_TEXT = 'No vulnerabilities found';
 
 /**
  * Base class of all compact representation types. By "compact" means that it
@@ -27,44 +27,44 @@ export default abstract class CompactGroupByRepresentation extends Representatio
   protected abstract groupFindings(): Map<string, Finding[]>
 
   protected composeByProperty<K extends keyof Pick<Finding, 'level' | 'severity'>>(key: K): string {
-    const grouped: Map<string, Finding[]> = this.groupFindings()
+    const grouped: Map<string, Finding[]> = this.groupFindings();
     if (grouped.size === 0) {
-      return NO_VULNS_FOUND_TEXT
+      return NO_VULNS_FOUND_TEXT;
     }
 
     return Array.from(grouped)
       .map(([title, findings]: [string, Finding[]]): string => {
-        findings.sort(findingsComparatorByKey(key))
+        findings.sort(findingsComparatorByKey(key));
         const summary: string =
           findings.length === 0
           ? NO_VULNS_FOUND_TEXT
-          : this.composeCompactReport(findings, key)
-        return `${title}\n${summary}`
+          : this.composeCompactReport(findings, key);
+        return `${title}\n${summary}`;
       })
-      .join('\n\n')
+      .join('\n\n');
   }
 
   private composeCompactReport<K extends keyof Pick<Finding, 'level' | 'severity'>>(findings: Finding[], key: K): string {
-    const result: string[] = []
+    const result: string[] = [];
     findings
       .reduce((grouped: Map<Finding[K], Array<Finding>>, f: Finding): Map<Finding[K], Array<Finding>> => {
         if (!grouped.get(f[key])) {
-          grouped.set(f[key], [] as Finding[])
+          grouped.set(f[key], [] as Finding[]);
         }
-        grouped.get(f[key])?.push(f)
-        return grouped
+        grouped.get(f[key])?.push(f);
+        return grouped;
       }, new Map<Finding[K], Array<Finding>>())
       .forEach((v: Array<Finding>, k: Finding[K]): void => {
-        result.push(`${this.bold(this.extractEnumValue(key, k))}: ${v.length}`)
+        result.push(`${this.bold(this.extractEnumValue(key, k))}: ${v.length}`);
       })
-    return result.join(', ')
+    return result.join(', ');
   }
 
   private extractEnumValue<K extends keyof Pick<Finding, 'level' | 'severity'>>(key: K, prop: Finding[K]): string {
     switch (key) {
-      case 'level': return SecurityLevel[Number(prop)]
-      case 'severity': return SecuritySeverity[Number(prop)]
-      default: throw new Error('Unknown property:', key)
+      case 'level': return SecurityLevel[Number(prop)];
+      case 'severity': return SecuritySeverity[Number(prop)];
+      default: throw new Error('Unknown property:', key);
     }
   }
 }

package/src/representations/CompactGroupByRunPerLevelRepresentation.ts

@@ -1,4 +1,4 @@
-import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation'
+import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation';
 
 /**
  * Since {@link CompactGroupByRunRepresentation} is an abstract class, the only
@@ -9,6 +9,6 @@ import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation'
 export default class CompactGroupByRunPerLevelRepresentation extends CompactGroupByRunRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('level')
+    return this.composeByProperty('level');
   }
 }

package/src/representations/CompactGroupByRunPerSeverityRepresentation.ts

@@ -1,4 +1,4 @@
-import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation'
+import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation';
 
 /**
  * Since {@link CompactGroupByRunRepresentation} is an abstract class, the only
@@ -9,6 +9,6 @@ import CompactGroupByRunRepresentation from './CompactGroupByRunRepresentation'
 export default class CompactGroupByRunPerSeverityRepresentation extends CompactGroupByRunRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('severity')
+    return this.composeByProperty('severity');
   }
 }

package/src/representations/CompactGroupByRunRepresentation.ts

@@ -1,6 +1,6 @@
-import type Finding from '../model/Finding'
-import CompactGroupByRepresentation from './CompactGroupByRepresentation'
-import type { SarifModel } from '../types'
+import type Finding from '../model/Finding';
+import CompactGroupByRepresentation from './CompactGroupByRepresentation';
+import type { SarifModel } from '../types';
 
 /**
  * Since {@link CompactGroupByRepresentation} already prepares compact representation
@@ -21,24 +21,24 @@ import type { SarifModel } from '../types'
 export default abstract class CompactGroupByRunRepresentation extends CompactGroupByRepresentation {
 
   public constructor(model: SarifModel) {
-    super(model, 'runId')
+    super(model, 'runId');
   }
 
   protected override groupFindings(): Map<string, Finding[]> {
-    const result = new Map<string, Finding[]>()
+    const result = new Map<string, Finding[]>();
     for (const run of this._model.runs) {
-      const key: string = this.composeGroupTitle(run.id, run.toolName)
+      const key: string = this.composeGroupTitle(run.id, run.toolName);
       if (result.get(key) == null) {
-        result.set(key, [])
+        result.set(key, []);
       }
       this._model.findings
         .filter((f: Finding): boolean => f.runId === run.id)
-        .forEach((f: Finding): number | undefined => result.get(key)?.push(f))
+        .forEach((f: Finding): number | undefined => result.get(key)?.push(f));
     }
-    return result
+    return result;
   }
 
   private composeGroupTitle(runId: number, toolName: string): string {
-    return `${this.italic(`[Run ${runId}]`)} ${this.bold(toolName)}`
+    return `${this.italic(`[Run ${runId}]`)} ${this.bold(toolName)}`;
   }
 }

package/src/representations/CompactGroupBySarifPerLevelRepresentation.ts

@@ -1,5 +1,5 @@
 import CompactGroupBySarifRepresentation
-  from './CompactGroupBySarifRepresentation'
+  from './CompactGroupBySarifRepresentation';
 
 /**
  * Since {@link CompactGroupBySarifRepresentation} is an abstract class, the only
@@ -10,6 +10,6 @@ import CompactGroupBySarifRepresentation
 export default class CompactGroupBySarifPerLevelRepresentation extends CompactGroupBySarifRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('level')
+    return this.composeByProperty('level');
   }
 }

package/src/representations/CompactGroupBySarifPerSeverityRepresentation.ts

@@ -1,5 +1,5 @@
 import CompactGroupBySarifRepresentation
-  from './CompactGroupBySarifRepresentation'
+  from './CompactGroupBySarifRepresentation';
 
 /**
  * Since {@link CompactGroupBySarifRepresentation} is an abstract class, the only
@@ -10,6 +10,6 @@ import CompactGroupBySarifRepresentation
 export default class CompactGroupBySarifPerSeverityRepresentation extends CompactGroupBySarifRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('severity')
+    return this.composeByProperty('severity');
   }
 }

package/src/representations/CompactGroupBySarifRepresentation.ts

@@ -1,7 +1,7 @@
-import path from 'node:path'
-import type Finding from '../model/Finding'
-import CompactGroupByRepresentation from './CompactGroupByRepresentation'
-import type { SarifModel } from '../types'
+import path from 'node:path';
+import type Finding from '../model/Finding';
+import CompactGroupByRepresentation from './CompactGroupByRepresentation';
+import type { SarifModel } from '../types';
 
 /**
  * Since {@link CompactGroupByRepresentation} already prepares compact representation
@@ -22,24 +22,24 @@ import type { SarifModel } from '../types'
 export default abstract class CompactGroupBySarifRepresentation extends CompactGroupByRepresentation {
 
   public constructor(model: SarifModel) {
-    super(model, 'sarifPath')
+    super(model, 'sarifPath');
   }
 
   protected override groupFindings(): Map<string, Finding[]> {
-    const result = new Map<string, Finding[]>()
+    const result = new Map<string, Finding[]>();
     for (let index = 0; index < this._model.sarifFiles.length; index++) {
-      const key: string = this.composeGroupTitle(this._model.sarifFiles[index], index)
+      const key: string = this.composeGroupTitle(this._model.sarifFiles[index], index);
       if (result.get(key) == null) {
-        result.set(key, [])
+        result.set(key, []);
       }
       this._model.findings
         .filter((f: Finding): boolean => f.sarifPath === this._model.sarifFiles[index])
-        .forEach((f: Finding) => result.get(key)?.push(f))
+        .forEach((f: Finding) => result.get(key)?.push(f));
     }
-    return result
+    return result;
   }
 
   private composeGroupTitle(sarifPath: string, index: number): string {
-    return `${this.italic(`[File ${index + 1}]`)} ${this.bold(path.basename(sarifPath))}`
+    return `${this.italic(`[File ${index + 1}]`)} ${this.bold(path.basename(sarifPath))}`;
   }
 }

package/src/representations/CompactGroupByToolNamePerLevelRepresentation.ts

@@ -1,5 +1,5 @@
 import CompactGroupByToolNameRepresentation
-  from './CompactGroupByToolNameRepresentation'
+  from './CompactGroupByToolNameRepresentation';
 
 /**
  * Since {@link CompactGroupByToolNameRepresentation} is an abstract class, the
@@ -10,6 +10,6 @@ import CompactGroupByToolNameRepresentation
 export default class CompactGroupByToolNamePerLevelRepresentation extends CompactGroupByToolNameRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('level')
+    return this.composeByProperty('level');
   }
 }

package/src/representations/CompactGroupByToolNamePerSeverityRepresentation.ts

@@ -1,5 +1,5 @@
 import CompactGroupByToolNameRepresentation
-  from './CompactGroupByToolNameRepresentation'
+  from './CompactGroupByToolNameRepresentation';
 
 /**
  * Since {@link CompactGroupByToolNameRepresentation} is an abstract class, the
@@ -10,6 +10,6 @@ import CompactGroupByToolNameRepresentation
 export default class CompactGroupByToolNamePerSeverityRepresentation extends CompactGroupByToolNameRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('severity')
+    return this.composeByProperty('severity');
   }
 }

package/src/representations/CompactGroupByToolNameRepresentation.ts

@@ -1,6 +1,6 @@
-import type Finding from '../model/Finding'
-import CompactGroupByRepresentation from './CompactGroupByRepresentation'
-import type { SarifModel } from '../types'
+import type Finding from '../model/Finding';
+import CompactGroupByRepresentation from './CompactGroupByRepresentation';
+import type { SarifModel } from '../types';
 
 /**
  * Since {@link CompactGroupByRepresentation} already prepares compact representation
@@ -21,24 +21,24 @@ import type { SarifModel } from '../types'
 export default abstract class CompactGroupByToolNameRepresentation extends CompactGroupByRepresentation {
 
   public constructor(model: SarifModel) {
-    super(model, 'toolName')
+    super(model, 'toolName');
   }
 
   protected override groupFindings(): Map<string, Finding[]> {
-    const result = new Map<string, Finding[]>()
+    const result = new Map<string, Finding[]>();
     for (const run of this._model.runs) {
-      const key: string = this.composeGroupTitle(run.toolName)
+      const key: string = this.composeGroupTitle(run.toolName);
       if (result.get(key) == null) {
-        result.set(key, [])
+        result.set(key, []);
       }
       this._model.findings
         .filter((f: Finding): boolean => f.runId === run.id)
-        .forEach((f: Finding) => result.get(key)?.push(f))
+        .forEach((f: Finding) => result.get(key)?.push(f));
     }
-    return result
+    return result;
   }
 
   private composeGroupTitle(toolName: string): string {
-    return this.bold(toolName)
+    return this.bold(toolName);
   }
 }

package/src/representations/CompactTotalPerLevelRepresentation.ts

@@ -1,4 +1,4 @@
-import CompactTotalRepresentation from './CompactTotalRepresentation'
+import CompactTotalRepresentation from './CompactTotalRepresentation';
 
 /**
  * Since {@link CompactTotalRepresentation} is an abstract class, the only
@@ -9,6 +9,6 @@ import CompactTotalRepresentation from './CompactTotalRepresentation'
 export default class CompactTotalPerLevelRepresentation extends CompactTotalRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('level')
+    return this.composeByProperty('level');
   }
 }

package/src/representations/CompactTotalPerSeverityRepresentation.ts

@@ -1,4 +1,4 @@
-import CompactTotalRepresentation from './CompactTotalRepresentation'
+import CompactTotalRepresentation from './CompactTotalRepresentation';
 
 /**
  * Since {@link CompactTotalRepresentation} is an abstract class, the only
@@ -9,6 +9,6 @@ import CompactTotalRepresentation from './CompactTotalRepresentation'
 export default class CompactTotalPerSeverityRepresentation extends CompactTotalRepresentation {
 
   public override compose(): string {
-    return this.composeByProperty('severity')
+    return this.composeByProperty('severity');
   }
 }

package/src/representations/CompactTotalRepresentation.ts

@@ -1,5 +1,5 @@
-import CompactGroupByRepresentation from './CompactGroupByRepresentation'
-import type Finding from '../model/Finding'
+import CompactGroupByRepresentation from './CompactGroupByRepresentation';
+import type Finding from '../model/Finding';
 
 /**
  * Since {@link CompactGroupByRepresentation} already prepares compact representation
@@ -18,10 +18,10 @@ import type Finding from '../model/Finding'
 export default abstract class CompactTotalRepresentation extends CompactGroupByRepresentation {
 
   protected override groupFindings(): Map<string, Finding[]> {
-    const result = new Map<string, Finding[]>()
+    const result = new Map<string, Finding[]>();
     if (this._model.findings.length > 0) {
-      result.set('Total', this._model.findings)
+      result.set('Total', this._model.findings);
     }
-    return result
+    return result;
   }
 }

package/src/representations/Representation.ts

@@ -9,31 +9,31 @@ import { findingsComparatorByKey } from '../utils/Comparators';
  * @internal
  */
 export default abstract class Representation {
-  protected readonly _model: SarifModel
+  protected readonly _model: SarifModel;
 
   public constructor(model: SarifModel, findingSortKey: keyof Finding = 'level') {
-    this._model = model
+    this._model = model;
     this._model.findings = model
       .findings
       .map((f: Finding): Finding => f.clone())
       .sort(findingsComparatorByKey(findingSortKey))
       .reduce((arr: FindingArray, f: Finding): FindingArray => {
-        arr.push(f)
-        return arr
-      }, new FindingArray())
+        arr.push(f);
+        return arr;
+      }, new FindingArray());
   }
 
   protected bold(text: string): string {
-    return `*${text}*`
+    return `*${text}*`;
   }
 
   protected italic(text: string): string {
-    return `_${text}_`
+    return `_${text}_`;
   }
 
   protected codeBlock(text: string): string {
     // biome-ignore lint/style/useTemplate: Template literals are unreadable here
-    return '```\n' + text + '\n```'
+    return '```\n' + text + '\n```';
   }
 
   abstract compose(): string

package/src/representations/RepresentationFactory.ts

@@ -1,33 +1,33 @@
-import type Representation from './Representation'
-import { RepresentationType, type SarifModel } from '../types'
+import type Representation from './Representation';
+import { RepresentationType, type SarifModel } from '../types';
 import CompactGroupByRunPerLevelRepresentation
-  from './CompactGroupByRunPerLevelRepresentation'
+  from './CompactGroupByRunPerLevelRepresentation';
 import CompactGroupByRunPerSeverityRepresentation
-  from './CompactGroupByRunPerSeverityRepresentation'
+  from './CompactGroupByRunPerSeverityRepresentation';
 import CompactGroupByToolNamePerLevelRepresentation
-  from './CompactGroupByToolNamePerLevelRepresentation'
+  from './CompactGroupByToolNamePerLevelRepresentation';
 import CompactGroupByToolNamePerSeverityRepresentation
-  from './CompactGroupByToolNamePerSeverityRepresentation'
+  from './CompactGroupByToolNamePerSeverityRepresentation';
 import CompactGroupBySarifPerLevelRepresentation
-  from './CompactGroupBySarifPerLevelRepresentation'
+  from './CompactGroupBySarifPerLevelRepresentation';
 import CompactGroupBySarifPerSeverityRepresentation
-  from './CompactGroupBySarifPerSeverityRepresentation'
+  from './CompactGroupBySarifPerSeverityRepresentation';
 import CompactTotalPerSeverityRepresentation
-  from './CompactTotalPerSeverityRepresentation'
+  from './CompactTotalPerSeverityRepresentation';
 import CompactTotalPerLevelRepresentation
-  from './CompactTotalPerLevelRepresentation'
+  from './CompactTotalPerLevelRepresentation';
 import TableGroupByToolNamePerLevelRepresentation
-  from './TableGroupByToolNamePerLevelRepresentation'
+  from './TableGroupByToolNamePerLevelRepresentation';
 import TableGroupByToolNamePerSeverityRepresentation
-  from './TableGroupByToolNamePerSeverityRepresentation'
+  from './TableGroupByToolNamePerSeverityRepresentation';
 import TableGroupByRunPerLevelRepresentation
-  from './TableGroupByRunPerLevelRepresentation'
+  from './TableGroupByRunPerLevelRepresentation';
 import TableGroupByRunPerSeverityRepresentation
-  from './TableGroupByRunPerSeverityRepresentation'
+  from './TableGroupByRunPerSeverityRepresentation';
 import TableGroupBySarifPerLevelRepresentation
-  from './TableGroupBySarifPerLevelRepresentation'
+  from './TableGroupBySarifPerLevelRepresentation';
 import TableGroupBySarifPerSeverityRepresentation
-  from './TableGroupBySarifPerSeverityRepresentation'
+  from './TableGroupBySarifPerSeverityRepresentation';
 
 /**
  * Factory class that creates a {@link Representation} class based on the provided
@@ -36,38 +36,38 @@ import TableGroupBySarifPerSeverityRepresentation
  */
 export function createRepresentation(
   model: SarifModel,
-  type: RepresentationType = RepresentationType.CompactGroupByToolNamePerSeverity
+  type: RepresentationType = RepresentationType.CompactGroupByToolNamePerSeverity,
 ): Representation {
   switch (type) {
     case RepresentationType.CompactGroupByRunPerLevel:
-      return new CompactGroupByRunPerLevelRepresentation(model)
+      return new CompactGroupByRunPerLevelRepresentation(model);
     case RepresentationType.CompactGroupByRunPerSeverity:
-      return new CompactGroupByRunPerSeverityRepresentation(model)
+      return new CompactGroupByRunPerSeverityRepresentation(model);
     case RepresentationType.CompactGroupByToolNamePerLevel:
-      return new CompactGroupByToolNamePerLevelRepresentation(model)
+      return new CompactGroupByToolNamePerLevelRepresentation(model);
     case RepresentationType.CompactGroupByToolNamePerSeverity:
-      return new CompactGroupByToolNamePerSeverityRepresentation(model)
+      return new CompactGroupByToolNamePerSeverityRepresentation(model);
     case RepresentationType.CompactGroupBySarifPerLevel:
-      return new CompactGroupBySarifPerLevelRepresentation(model)
+      return new CompactGroupBySarifPerLevelRepresentation(model);
     case RepresentationType.CompactGroupBySarifPerSeverity:
-      return new CompactGroupBySarifPerSeverityRepresentation(model)
+      return new CompactGroupBySarifPerSeverityRepresentation(model);
     case RepresentationType.CompactTotalPerLevel:
-      return new CompactTotalPerLevelRepresentation(model)
+      return new CompactTotalPerLevelRepresentation(model);
     case RepresentationType.CompactTotalPerSeverity:
-      return new CompactTotalPerSeverityRepresentation(model)
+      return new CompactTotalPerSeverityRepresentation(model);
     case RepresentationType.TableGroupByRunPerLevel:
-      return new TableGroupByRunPerLevelRepresentation(model)
+      return new TableGroupByRunPerLevelRepresentation(model);
     case RepresentationType.TableGroupByRunPerSeverity:
-      return new TableGroupByRunPerSeverityRepresentation(model)
+      return new TableGroupByRunPerSeverityRepresentation(model);
     case RepresentationType.TableGroupByToolNamePerLevel:
-      return new TableGroupByToolNamePerLevelRepresentation(model)
+      return new TableGroupByToolNamePerLevelRepresentation(model);
     case RepresentationType.TableGroupByToolNamePerSeverity:
-      return new TableGroupByToolNamePerSeverityRepresentation(model)
+      return new TableGroupByToolNamePerSeverityRepresentation(model);
     case RepresentationType.TableGroupBySarifPerLevel:
-      return new TableGroupBySarifPerLevelRepresentation(model)
+      return new TableGroupBySarifPerLevelRepresentation(model);
     case RepresentationType.TableGroupBySarifPerSeverity:
-      return new TableGroupBySarifPerSeverityRepresentation(model)
+      return new TableGroupBySarifPerSeverityRepresentation(model);
     default:
-      throw new Error(`Unknown representation type: ${type}`)
+      throw new Error(`Unknown representation type: ${type}`);
   }
 }

package/src/representations/TableGroupByRunPerLevelRepresentation.ts

@@ -1,9 +1,9 @@
-import { type SarifModel, SecurityLevelValues } from '../types'
-import TableGroupByRunRepresentation from './TableGroupByRunRepresentation'
+import { type SarifModel, SecurityLevelValues } from '../types';
+import TableGroupByRunRepresentation from './TableGroupByRunRepresentation';
 
 export default class TableGroupByRunPerLevelRepresentation extends TableGroupByRunRepresentation<'level'> {
 
   public constructor(model: SarifModel) {
-    super('level', SecurityLevelValues, model)
+    super('level', SecurityLevelValues, model);
   }
 }

package/src/representations/TableGroupByRunPerSeverityRepresentation.ts

@@ -1,9 +1,9 @@
-import { type SarifModel, SecuritySeverityValues } from '../types'
-import TableGroupByRunRepresentation from './TableGroupByRunRepresentation'
+import { type SarifModel, SecuritySeverityValues } from '../types';
+import TableGroupByRunRepresentation from './TableGroupByRunRepresentation';
 
 export default class TableGroupByRunPerSeverityRepresentation extends TableGroupByRunRepresentation<'severity'> {
 
   public constructor(model: SarifModel) {
-    super('severity', SecuritySeverityValues, model)
+    super('severity', SecuritySeverityValues, model);
   }
 }

package/src/representations/TableGroupByRunRepresentation.ts

@@ -1,6 +1,6 @@
-import type { SarifModel } from '../types'
-import type Finding from '../model/Finding'
-import TableGroupRepresentation from './TableGroupRepresentation'
+import type { SarifModel } from '../types';
+import type Finding from '../model/Finding';
+import TableGroupRepresentation from './TableGroupRepresentation';
 
 export default abstract class TableGroupByRunRepresentation<
   KPer extends keyof Pick<Finding, 'level' | 'severity'>
@@ -8,8 +8,8 @@ export default abstract class TableGroupByRunRepresentation<
   protected constructor(
     keyPer: KPer,
     values: string[],
-    model: SarifModel
+    model: SarifModel,
   ) {
-    super('runId', keyPer, values, model)
+    super('runId', keyPer, values, model);
   }
 }

package/src/representations/TableGroupBySarifPerLevelRepresentation.ts

@@ -1,9 +1,9 @@
-import { type SarifModel, SecurityLevelValues } from '../types'
-import TableGroupBySarifRepresentation from './TableGroupBySarifRepresentation'
+import { type SarifModel, SecurityLevelValues } from '../types';
+import TableGroupBySarifRepresentation from './TableGroupBySarifRepresentation';
 
 export default class TableGroupBySarifPerLevelRepresentation extends TableGroupBySarifRepresentation<'level'> {
 
   public constructor(model: SarifModel) {
-    super('level', SecurityLevelValues, model)
+    super('level', SecurityLevelValues, model);
   }
 }

package/src/representations/TableGroupBySarifPerSeverityRepresentation.ts

@@ -1,9 +1,9 @@
-import { type SarifModel, SecuritySeverityValues } from '../types'
-import TableGroupBySarifRepresentation from './TableGroupBySarifRepresentation'
+import { type SarifModel, SecuritySeverityValues } from '../types';
+import TableGroupBySarifRepresentation from './TableGroupBySarifRepresentation';
 
 export default class TableGroupBySarifPerSeverityRepresentation extends TableGroupBySarifRepresentation<'severity'> {
 
   public constructor(model: SarifModel) {
-    super('severity', SecuritySeverityValues, model)
+    super('severity', SecuritySeverityValues, model);
   }
 }