@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/dist/src/util/logger.js

@@ -0,0 +1,94 @@
+const LEVEL_PADDINGS = {
+    TRACE: "    ",
+    DEBUG: "    ",
+    INFO: "     ",
+    WARN: "     ",
+    ERROR: "    ",
+};
+export const debugEnabled = (() => {
+    // In a node-like environment, check for the environment variable.
+    if (typeof globalThis.process !== "undefined" && globalThis.process.env) {
+        return globalThis.process.env["MPEG_SDL_PARSER_DEBUG"] !== undefined;
+    }
+    // In a browser-like environment, check for the local storage item.
+    if (typeof localStorage !== "undefined") {
+        try {
+            return localStorage.getItem("MPEG_SDL_PARSER_DEBUG") !== null;
+        }
+        catch {
+            // Ignore SecurityError if localStorage is disabled.
+            return false;
+        }
+    }
+    return false;
+})();
+let maxLoggerNameLength = 0;
+const LOGGER_NAME_PADDINGS = {};
+function getDefaultLogger() {
+    return {
+        trace: () => { },
+        debug: (message, ...optionalParams) => {
+            console.debug(message, ...optionalParams);
+        },
+        info: (message, ...optionalParams) => {
+            console.info(message, ...optionalParams);
+        },
+        warn: (message, ...optionalParams) => {
+            console.warn(message, ...optionalParams);
+        },
+        error: (message, ...optionalParams) => {
+            console.error(message, ...optionalParams);
+        },
+    };
+}
+function wrapDefaultLogger(loggerName, levelPadding, loggerFunction) {
+    return (message, ...optionalParams) => {
+        if (message instanceof Function) {
+            loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${message()}`, ...optionalParams);
+            return;
+        }
+        if (message instanceof Object) {
+            loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${JSON.stringify(message)}`, ...optionalParams);
+            return;
+        }
+        loggerFunction(`${levelPadding} [${loggerName}]${LOGGER_NAME_PADDINGS[loggerName]} ${message}`, ...optionalParams);
+    };
+}
+/**
+ * Retrieves a logger instance with the specified name. If the name length exceeds the current maximum logger name length,
+ * it updates the padding for all existing logger names to ensure consistent formatting.
+ *
+ * @param loggerName The name of the logger to retrieve.
+ * @returns A logger instance with the specified name.
+ */
+export default function getLogger(loggerName) {
+    if (globalThis.defaultLogger === undefined) {
+        globalThis.defaultLogger = getDefaultLogger();
+    }
+    if (loggerName.length > maxLoggerNameLength) {
+        maxLoggerNameLength = loggerName.length;
+        for (const key of Object.keys(LOGGER_NAME_PADDINGS)) {
+            LOGGER_NAME_PADDINGS[key] = " ".repeat(maxLoggerNameLength - key.length);
+        }
+        LOGGER_NAME_PADDINGS[loggerName] = "";
+    }
+    else if (LOGGER_NAME_PADDINGS[loggerName] === undefined) {
+        LOGGER_NAME_PADDINGS[loggerName] = " ".repeat(maxLoggerNameLength - loggerName.length);
+    }
+    if (debugEnabled) {
+        return {
+            trace: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.TRACE, globalThis.defaultLogger.trace),
+            debug: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.DEBUG, globalThis.defaultLogger.debug),
+            info: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.INFO, globalThis.defaultLogger.info),
+            warn: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.WARN, globalThis.defaultLogger.warn),
+            error: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.ERROR, globalThis.defaultLogger.error),
+        };
+    }
+    return {
+        trace: () => { },
+        debug: () => { },
+        info: () => { },
+        warn: () => { },
+        error: wrapDefaultLogger(loggerName, LEVEL_PADDINGS.ERROR, globalThis.defaultLogger.error),
+    };
+}

package/package.json

@@ -1,61 +1,65 @@
 {
   "name": "@mpeggroup/mpeg-sdl-parser",
+  "version": "4.1.3",
   "description": "ISO/IEC 14496-34 Syntactic Description Language (MPEG SDL) parser implemented in TypeScript",
+  "keywords": [
+    "bun",
+    "mpeg",
+    "parser",
+    "sdl"
+  ],
   "homepage": "https://github.com/MPEGGroup/mpeg-sdl-parser#readme",
+  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/MPEGGroup/mpeg-sdl-parser.git"
   },
-  "scripts": {
-    "build": "bun build --entrypoints ./index.ts --outdir ./dist --target node --format esm --external '@lezer/*' --external '@codemirror/*' --external 'prettier'",
-    "prepublishOnly": "bun run build",
-    "generate": "lezer-generator --typeScript --output src/lezer/parser ./grammar/sdl.lezer.grammar"
-  },
-  "license": "MIT",
-  "keywords": [
-    "bun",
-    "mpeg",
-    "sdl",
-    "parser"
-  ],
-  "module": "index.ts",
-  "main": "dist/index.js",
-  "type": "module",
-  "version": "4.1.1",
   "files": [
     "dist",
     "grammar",
     "src",
-    "tests",
-    "bun.lock",
     "index.ts",
     "LICENSE",
-    "package.json",
-    "README.md",
-    "tsconfig.json"
+    "README.md"
   ],
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "bun": "./index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@types/bun": "^1.3.13",
-    "@types/node": "^25.6.0"
-  },
-  "peerDependencies": {
-    "typescript": "6.0.3"
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "generate": "lezer-generator --typeScript --output src/lezer/parser ./grammar/sdl.lezer.grammar"
   },
   "dependencies": {
-    "@codemirror/state": "6.5.4",
     "@codemirror/language": "6.12.3",
+    "@codemirror/state": "6.5.4",
     "@lezer/common": "1.5.0",
     "@lezer/generator": "1.8.0",
     "@lezer/highlight": "1.2.3",
     "@lezer/lr": "1.4.7",
     "prettier": "3.8.3"
   },
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
+    "@types/node": "^25.9.1"
+  },
+  "peerDependencies": {
+    "typescript": "6.0.3"
+  },
   "overrides": {
+    "@codemirror/state": "6.5.4",
     "@lezer/common": "1.5.0",
-    "@lezer/lr": "1.4.7",
-    "@codemirror/state": "6.5.4"
+    "@lezer/lr": "1.4.7"
   }
 }

package/src/analyser/checks/check-array-definition.ts

@@ -9,25 +9,18 @@ import { isIdentifier, isNumberLiteral } from "../../ast/util/types.ts";
 import type { SymbolTable } from "../symbol-table.ts";
 import type { Check, CheckResult } from "./check.ts";
 
-function checkArrayDimensionsPositiveInteger(
-  definition: ArrayDefinition,
-): CheckResult[] {
+function checkArrayDimensionsPositiveInteger(definition: ArrayDefinition): CheckResult[] {
   const results: CheckResult[] = [];
 
   for (const dimension of definition.dimensions) {
     if (dimension.nodeKind === NodeKind.ARRAY_DIMENSION) {
       const explicitDimension = dimension as ExplicitArrayDimension;
-      if (
-        explicitDimension.arrayDimensionKind === ArrayDimensionKind.EXPLICIT
-      ) {
+      if (explicitDimension.arrayDimensionKind === ArrayDimensionKind.EXPLICIT) {
         const size = explicitDimension.size;
 
         // Only check direct NumberLiterals, skip expressions as per spec note
         if (isNumberLiteral(size)) {
-          if (
-            size.value <= 0 ||
-            size.numberLiteralKind !== NumberLiteralKind.INTEGER
-          ) {
+          if (size.value <= 0 || size.numberLiteralKind !== NumberLiteralKind.INTEGER) {
             results.push({
               message: "Array dimensions must be a positive integer.",
               location: size.startToken!.getLocation(),
@@ -52,17 +45,14 @@ function checkImplicitArrayClassId(
     definition.classIdentifier &&
     isIdentifier(definition.classIdentifier)
   ) {
-    const classSymbol = symbolTable.lookupClass(
-      definition.classIdentifier.name,
-    );
+    const classSymbol = symbolTable.lookupClass(definition.classIdentifier.name);
 
     if (classSymbol) {
       const classDeclaration = classSymbol.node as ClassDeclaration;
 
       if (!classDeclaration.bitModifier) {
         results.push({
-          message:
-            "Implicit arrays can only contain classes which have a classId defined.",
+          message: "Implicit arrays can only contain classes which have a classId defined.",
           location: definition.classIdentifier.startToken!.getLocation(),
         });
       }

package/src/analyser/checks/check-array-element-access.ts

@@ -6,11 +6,7 @@ import type { Check, CheckResult } from "./check.ts";
 
 export const checkArrayElementAccess: Check = {
   nodeKind: NodeKind.ARRAY_ELEMENT_ACCESS,
-  checkFunc: function (
-    node: ArrayElementAccess,
-    _symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (node: ArrayElementAccess, _symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     if (isNumberLiteral(node.index)) {

package/src/analyser/checks/check-class-declaration.ts

@@ -40,21 +40,13 @@ function collectAllIdentifiers(node: AbstractNode): string[] {
   return identifiers;
 }
 
-function checkMaxClassSizePositiveInteger(
-  declaration: ClassDeclaration,
-): CheckResult[] {
+function checkMaxClassSizePositiveInteger(declaration: ClassDeclaration): CheckResult[] {
   const results: CheckResult[] = [];
 
-  if (
-    declaration.expandableModifier &&
-    isExpandableModifier(declaration.expandableModifier)
-  ) {
+  if (declaration.expandableModifier && isExpandableModifier(declaration.expandableModifier)) {
     const maxClassSize = declaration.expandableModifier.maxClassSize;
     if (maxClassSize && isNumberLiteral(maxClassSize)) {
-      if (
-        maxClassSize.value <= 0 ||
-        maxClassSize.numberLiteralKind !== NumberLiteralKind.INTEGER
-      ) {
+      if (maxClassSize.value <= 0 || maxClassSize.numberLiteralKind !== NumberLiteralKind.INTEGER) {
         results.push({
           message: "maxClassSize must be a positive integer",
           location: maxClassSize.startToken!.getLocation(),
@@ -66,15 +58,14 @@ function checkMaxClassSizePositiveInteger(
   return results;
 }
 
-function checkExpandableCannotBeAbstract(
-  declaration: ClassDeclaration,
-): CheckResult[] {
+function checkExpandableCannotBeAbstract(declaration: ClassDeclaration): CheckResult[] {
   const results: CheckResult[] = [];
 
   if (
     declaration.expandableModifier &&
     isExpandableModifier(declaration.expandableModifier) &&
-    declaration.abstractKeyword && isToken(declaration.abstractKeyword)
+    declaration.abstractKeyword &&
+    isToken(declaration.abstractKeyword)
   ) {
     results.push({
       message:
@@ -113,15 +104,10 @@ function checkParameterReferencedWithinClass(
       continue;
     }
     const parameter = param as Parameter;
-    const identifier = getRequiredIdentifier(
-      parameter.identifier,
-      parameter,
-      strict,
-    );
+    const identifier = getRequiredIdentifier(parameter.identifier, parameter, strict);
     if (identifier && !classBodyIdentifiers.has(identifier.name)) {
       results.push({
-        message:
-          "A parameter in a parameter list must be referenced within the class declaration.",
+        message: "A parameter in a parameter list must be referenced within the class declaration.",
         location: identifier.startToken!.getLocation(),
       });
     }
@@ -146,9 +132,7 @@ function checkClassIdNotInValidRangeOfBaseClass(
     return results;
   }
 
-  const baseClassSymbol = symbolTable.lookupClass(
-    extendsModifier.identifier.name,
-  );
+  const baseClassSymbol = symbolTable.lookupClass(extendsModifier.identifier.name);
 
   if (!baseClassSymbol) {
     return results;
@@ -167,56 +151,34 @@ function checkClassIdNotInValidRangeOfBaseClass(
   const baseBitModifier = baseClass.bitModifier;
   const thisBitModifier = declaration.bitModifier;
 
-  if (
-    (baseBitModifier.classId as AbstractClassId).classIdKind ===
-      ClassIdKind.RANGE
-  ) {
+  if ((baseBitModifier.classId as AbstractClassId).classIdKind === ClassIdKind.RANGE) {
     const baseRange = baseBitModifier.classId as ClassIdRange;
     const baseStartClassId = baseRange.startClassId as ClassId;
     const baseEndClassId = baseRange.endClassId as ClassId;
-    const baseMin = isNumberLiteral(baseStartClassId.value)
-      ? baseStartClassId.value.value
-      : null;
-    const baseMax = isNumberLiteral(baseEndClassId.value)
-      ? baseEndClassId.value.value
-      : null;
+    const baseMin = isNumberLiteral(baseStartClassId.value) ? baseStartClassId.value.value : null;
+    const baseMax = isNumberLiteral(baseEndClassId.value) ? baseEndClassId.value.value : null;
 
     if (baseMin !== null && baseMax !== null) {
-      if (
-        (thisBitModifier.classId as AbstractClassId).classIdKind ===
-          ClassIdKind.SINGLE
-      ) {
+      if ((thisBitModifier.classId as AbstractClassId).classIdKind === ClassIdKind.SINGLE) {
         const thisClassId = thisBitModifier.classId as ClassId;
-        const thisValue = isNumberLiteral(thisClassId.value)
-          ? thisClassId.value.value
-          : null;
-        if (
-          thisValue !== null && (thisValue < baseMin || thisValue > baseMax)
-        ) {
+        const thisValue = isNumberLiteral(thisClassId.value) ? thisClassId.value.value : null;
+        if (thisValue !== null && (thisValue < baseMin || thisValue > baseMax)) {
           results.push({
             message:
               "The specified classId is not within the range of valid classIds specified in the base class.",
             location: thisBitModifier.startToken!.getLocation(),
           });
         }
-      } else if (
-        (thisBitModifier.classId as AbstractClassId).classIdKind ===
-          ClassIdKind.RANGE
-      ) {
+      } else if ((thisBitModifier.classId as AbstractClassId).classIdKind === ClassIdKind.RANGE) {
         const thisRange = thisBitModifier.classId as ClassIdRange;
         const thisStartClassId = thisRange.startClassId as ClassId;
         const thisEndClassId = thisRange.endClassId as ClassId;
         const thisMin = isNumberLiteral(thisStartClassId.value)
           ? thisStartClassId.value.value
           : null;
-        const thisMax = isNumberLiteral(thisEndClassId.value)
-          ? thisEndClassId.value.value
-          : null;
+        const thisMax = isNumberLiteral(thisEndClassId.value) ? thisEndClassId.value.value : null;
 
-        if (
-          (thisMin !== null) && (thisMax !== null) &&
-          ((thisMin < baseMin) || (thisMax > baseMax))
-        ) {
+        if (thisMin !== null && thisMax !== null && (thisMin < baseMin || thisMax > baseMax)) {
           results.push({
             message:
               "The specified classId is not within the range of valid classIds specified in the base class.",
@@ -230,9 +192,7 @@ function checkClassIdNotInValidRangeOfBaseClass(
   return results;
 }
 
-function checkCannotExtendItself(
-  declaration: ClassDeclaration,
-): CheckResult[] {
+function checkCannotExtendItself(declaration: ClassDeclaration): CheckResult[] {
   const results: CheckResult[] = [];
 
   if (!isExtendsModifier(declaration.extendsModifier)) {
@@ -241,10 +201,7 @@ function checkCannotExtendItself(
 
   const extendsModifier = declaration.extendsModifier;
 
-  if (
-    !isIdentifier(extendsModifier.identifier) ||
-    !isIdentifier(declaration.identifier)
-  ) {
+  if (!isIdentifier(extendsModifier.identifier) || !isIdentifier(declaration.identifier)) {
     return results;
   }
 
@@ -258,9 +215,7 @@ function checkCannotExtendItself(
   return results;
 }
 
-function checkCannotRecursivelyContainItself(
-  declaration: ClassDeclaration,
-): CheckResult[] {
+function checkCannotRecursivelyContainItself(declaration: ClassDeclaration): CheckResult[] {
   const results: CheckResult[] = [];
 
   if (!isIdentifier(declaration.identifier)) {
@@ -277,10 +232,7 @@ function checkCannotRecursivelyContainItself(
           StatementKind.CLASS_DEFINITION
       ) {
         const classDef = statement as ClassDefinition;
-        if (
-          isIdentifier(classDef.classIdentifier) &&
-          classDef.classIdentifier.name === className
-        ) {
+        if (isIdentifier(classDef.classIdentifier) && classDef.classIdentifier.name === className) {
           return true;
         }
       }
@@ -318,9 +270,7 @@ function checkExpandableCannotExtendExpandable(
     return results;
   }
 
-  const baseClassSymbol = symbolTable.lookupClass(
-    extendsModifier.identifier.name,
-  );
+  const baseClassSymbol = symbolTable.lookupClass(extendsModifier.identifier.name);
 
   if (!baseClassSymbol) {
     return results;
@@ -365,10 +315,7 @@ function checkAlignmentMustMatchBaseClass(
 
   if (isAlignedModifier(declaration.alignedModifier)) {
     if (isAlignedModifier(baseClass.alignedModifier)) {
-      if (
-        declaration.alignedModifier.alignment !==
-          baseClass.alignedModifier.alignment
-      ) {
+      if (declaration.alignedModifier.alignment !== baseClass.alignedModifier.alignment) {
         results.push({
           message:
             "The alignment of a class which extends another must not differ from the alignment of the base class.",
@@ -402,14 +349,10 @@ export const checkClassDeclaration: Check = {
     results.push(...checkMaxClassSizePositiveInteger(declaration));
     results.push(...checkExpandableCannotBeAbstract(declaration));
     results.push(...checkParameterReferencedWithinClass(declaration, strict));
-    results.push(
-      ...checkClassIdNotInValidRangeOfBaseClass(declaration, symbolTable),
-    );
+    results.push(...checkClassIdNotInValidRangeOfBaseClass(declaration, symbolTable));
     results.push(...checkCannotExtendItself(declaration));
     results.push(...checkCannotRecursivelyContainItself(declaration));
-    results.push(
-      ...checkExpandableCannotExtendExpandable(declaration, symbolTable),
-    );
+    results.push(...checkExpandableCannotExtendExpandable(declaration, symbolTable));
     results.push(...checkAlignmentMustMatchBaseClass(declaration, symbolTable));
 
     return results;

package/src/analyser/checks/check-computed-array-definition.ts

@@ -10,25 +10,16 @@ import type { Check, CheckResult } from "./check.ts";
 export const checkComputedArrayDefinition: Check = {
   nodeKind: NodeKind.STATEMENT,
   subKind: StatementKind.COMPUTED_ARRAY_DEFINITION,
-  checkFunc: function (
-    definition: ComputedArrayDefinition,
-    _symbolTable,
-    _strict,
-  ): CheckResult[] {
+  checkFunc: function (definition: ComputedArrayDefinition, _symbolTable, _strict): CheckResult[] {
     const results: CheckResult[] = [];
 
     for (const dimension of definition.dimensions) {
       if (dimension.nodeKind === NodeKind.ARRAY_DIMENSION) {
         const explicitDimension = dimension as ExplicitArrayDimension;
-        if (
-          explicitDimension.arrayDimensionKind === ArrayDimensionKind.EXPLICIT
-        ) {
+        if (explicitDimension.arrayDimensionKind === ArrayDimensionKind.EXPLICIT) {
           const size = explicitDimension.size;
           if (isNumberLiteral(size)) {
-            if (
-              size.value <= 0 ||
-              size.numberLiteralKind !== NumberLiteralKind.INTEGER
-            ) {
+            if (size.value <= 0 || size.numberLiteralKind !== NumberLiteralKind.INTEGER) {
               results.push({
                 message: "Array dimensions must be a positive integer.",
                 location: size.startToken!.getLocation(),

package/src/analyser/checks/check-computed-elementary-type-definition.ts

@@ -17,11 +17,7 @@ export const checkComputedElementaryTypeDefinition: Check = {
       return [];
     }
 
-    const identifier = getRequiredIdentifier(
-      definition.identifier,
-      definition,
-      strict,
-    );
+    const identifier = getRequiredIdentifier(definition.identifier, definition, strict);
 
     if (!identifier) {
       return [];
@@ -36,8 +32,7 @@ export const checkComputedElementaryTypeDefinition: Check = {
 
     return [
       {
-        message:
-          `${identifier.name}: const computed elementary type definition must have a value specified`,
+        message: `${identifier.name}: const computed elementary type definition must have a value specified`,
         location: identifier.startToken!.getLocation(),
       },
     ];

package/src/analyser/checks/check-elementary-type-definition.ts

@@ -1,68 +1,63 @@
-import type { LengthAttribute } from "../../../dist/index.js";
 import type { ElementaryTypeDefinition } from "../../ast/node/elementary-type-definition.ts";
 import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.ts";
 import { NodeKind } from "../../ast/node/enum/node-kind.ts";
 import { StatementKind } from "../../ast/node/enum/statement-kind.ts";
+import type { LengthAttribute } from "../../ast/node/length-attribute.ts";
 import type { NumberLiteral } from "../../ast/node/number-literal.ts";
 import { isNumberLiteral } from "../../ast/util/types.ts";
-import {
-  getElementaryTypeKind,
-  getRequiredElementaryType,
-} from "../util/symbol-table-utils.ts";
+import { getElementaryTypeKind, getRequiredElementaryType } from "../util/symbol-table-utils.ts";
 import type { Check, CheckResult } from "./check.ts";
 
-function checkOptionalCannotDefineRange(
-  definition: ElementaryTypeDefinition,
-): CheckResult[] {
-  if (
-    definition.assignmentOperator === undefined &&
-    definition.rangeOperator !== undefined
-  ) {
+function checkOptionalCannotDefineRange(definition: ElementaryTypeDefinition): CheckResult[] {
+  if (definition.assignmentOperator === undefined && definition.rangeOperator !== undefined) {
     const location = definition.startToken?.getLocation();
     if (location) {
-      return [{
-        message:
-          "An optional elementary type definition cannot define a range for a value.",
-        location,
-      }];
+      return [
+        {
+          message: "An optional elementary type definition cannot define a range for a value.",
+          location,
+        },
+      ];
     }
   }
   return [];
 }
 
-function checkRangeMinMaxValidation(
-  definition: ElementaryTypeDefinition,
-): CheckResult[] {
+function checkRangeMinMaxValidation(definition: ElementaryTypeDefinition): CheckResult[] {
   if (
-    definition.value && definition.endValue &&
-    isNumberLiteral(definition.value) && isNumberLiteral(definition.endValue)
+    definition.value &&
+    definition.endValue &&
+    isNumberLiteral(definition.value) &&
+    isNumberLiteral(definition.endValue)
   ) {
     const minValue = definition.value as NumberLiteral;
     const maxValue = definition.endValue as NumberLiteral;
 
     // Check that types match
     if (minValue.numberLiteralKind !== maxValue.numberLiteralKind) {
-      const location = maxValue.startToken?.getLocation() ||
-        definition.startToken!.getLocation();
+      const location = maxValue.startToken?.getLocation() || definition.startToken!.getLocation();
       if (location) {
-        return [{
-          message:
-            "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
-          location,
-        }];
+        return [
+          {
+            message:
+              "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
+            location,
+          },
+        ];
       }
     }
 
     // Check that max >= min
     if (maxValue.value < minValue.value) {
-      const location = maxValue.startToken?.getLocation() ||
-        definition.startToken!.getLocation();
+      const location = maxValue.startToken?.getLocation() || definition.startToken!.getLocation();
       if (location) {
-        return [{
-          message:
-            "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
-          location,
-        }];
+        return [
+          {
+            message:
+              "The min_value and max_value must be of the same type and the max_value must be greater than or equal to the min_value.",
+            location,
+          },
+        ];
       }
     }
   }
@@ -73,11 +68,7 @@ function checkValueRepresentability(
   definition: ElementaryTypeDefinition,
   strict: boolean,
 ): CheckResult[] {
-  const elementaryType = getRequiredElementaryType(
-    definition.elementaryType,
-    definition,
-    strict,
-  );
+  const elementaryType = getRequiredElementaryType(definition.elementaryType, definition, strict);
 
   if (!elementaryType) {
     return [];
@@ -131,14 +122,16 @@ function checkValueRepresentability(
     }
 
     if (!isValid) {
-      const location = valueLiteral.startToken?.getLocation() ||
-        definition.startToken!.getLocation();
+      const location =
+        valueLiteral.startToken?.getLocation() || definition.startToken!.getLocation();
       if (location) {
-        return [{
-          message:
-            "The specified value cannot be represented using the specific width of the variable.",
-          location,
-        }];
+        return [
+          {
+            message:
+              "The specified value cannot be represented using the specific width of the variable.",
+            location,
+          },
+        ];
       }
     }
   }