@mpeggroup/mpeg-sdl-parser 4.1.2 → 4.1.3

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkArrayDefinition: Check;
+//# sourceMappingURL=check-array-definition.d.ts.map

package/dist/src/analyser/checks/check-array-definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-array-definition.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-array-definition.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAuDrD,eAAO,MAAM,oBAAoB,EAAE,KAelC,CAAC"}

package/dist/src/analyser/checks/check-array-definition.js

@@ -0,0 +1,54 @@
+import { ArrayDimensionKind } from "../../ast/node/enum/array-dimension-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isIdentifier, isNumberLiteral } from "../../ast/util/types.js";
+function checkArrayDimensionsPositiveInteger(definition) {
+    const results = [];
+    for (const dimension of definition.dimensions) {
+        if (dimension.nodeKind === NodeKind.ARRAY_DIMENSION) {
+            const explicitDimension = dimension;
+            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) {
+                        results.push({
+                            message: "Array dimensions must be a positive integer.",
+                            location: size.startToken.getLocation(),
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return results;
+}
+function checkImplicitArrayClassId(definition, symbolTable) {
+    const results = [];
+    if (definition.implicitArrayDimension &&
+        definition.classIdentifier &&
+        isIdentifier(definition.classIdentifier)) {
+        const classSymbol = symbolTable.lookupClass(definition.classIdentifier.name);
+        if (classSymbol) {
+            const classDeclaration = classSymbol.node;
+            if (!classDeclaration.bitModifier) {
+                results.push({
+                    message: "Implicit arrays can only contain classes which have a classId defined.",
+                    location: definition.classIdentifier.startToken.getLocation(),
+                });
+            }
+        }
+    }
+    return results;
+}
+export const checkArrayDefinition = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.ARRAY_DEFINITION,
+    checkFunc: function (definition, symbolTable, _strict) {
+        const results = [];
+        results.push(...checkArrayDimensionsPositiveInteger(definition));
+        results.push(...checkImplicitArrayClassId(definition, symbolTable));
+        return results;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkArrayElementAccess: Check;
+//# sourceMappingURL=check-array-element-access.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-array-element-access.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-array-element-access.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,uBAAuB,EAAE,KAoBrC,CAAC"}

package/dist/src/analyser/checks/check-array-element-access.js

@@ -0,0 +1,19 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+import { isNumberLiteral } from "../../ast/util/types.js";
+export const checkArrayElementAccess = {
+    nodeKind: NodeKind.ARRAY_ELEMENT_ACCESS,
+    checkFunc: function (node, _symbolTable, _strict) {
+        const results = [];
+        if (isNumberLiteral(node.index)) {
+            if (node.index.numberLiteralKind === NumberLiteralKind.FLOATING_POINT ||
+                node.index.value < 0) {
+                results.push({
+                    message: "Array element access cannot be performed with floating point or negative integer values.",
+                    location: node.index.startToken.getLocation(),
+                });
+            }
+        }
+        return results;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkClassDeclaration: Check;
+//# sourceMappingURL=check-class-declaration.d.ts.map

package/dist/src/analyser/checks/check-class-declaration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-class-declaration.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-class-declaration.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AA6TrD,eAAO,MAAM,qBAAqB,EAAE,KAqBnC,CAAC"}

package/dist/src/analyser/checks/check-class-declaration.js

@@ -0,0 +1,252 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { ClassIdKind } from "../../ast/node/enum/class-id-kind.js";
+import { isAlignedModifier, isBitModifier, isCompositeNode, isExpandableModifier, isExtendsModifier, isIdentifier, isNumberLiteral, isToken, } from "../../ast/util/types.js";
+import { getRequiredIdentifier } from "../util/symbol-table-utils.js";
+function collectAllIdentifiers(node) {
+    const identifiers = [];
+    if (isIdentifier(node)) {
+        identifiers.push(node.name);
+    }
+    if (isCompositeNode(node)) {
+        for (const child of node.children) {
+            identifiers.push(...collectAllIdentifiers(child));
+        }
+    }
+    return identifiers;
+}
+function checkMaxClassSizePositiveInteger(declaration) {
+    const results = [];
+    if (declaration.expandableModifier && isExpandableModifier(declaration.expandableModifier)) {
+        const maxClassSize = declaration.expandableModifier.maxClassSize;
+        if (maxClassSize && isNumberLiteral(maxClassSize)) {
+            if (maxClassSize.value <= 0 || maxClassSize.numberLiteralKind !== NumberLiteralKind.INTEGER) {
+                results.push({
+                    message: "maxClassSize must be a positive integer",
+                    location: maxClassSize.startToken.getLocation(),
+                });
+            }
+        }
+    }
+    return results;
+}
+function checkExpandableCannotBeAbstract(declaration) {
+    const results = [];
+    if (declaration.expandableModifier &&
+        isExpandableModifier(declaration.expandableModifier) &&
+        declaration.abstractKeyword &&
+        isToken(declaration.abstractKeyword)) {
+        results.push({
+            message: "Because the class is expandable, it has an encoded sizeOfInstance value therefore it cannot be abstract.",
+            location: declaration.abstractKeyword.getLocation(),
+        });
+    }
+    return results;
+}
+function checkParameterReferencedWithinClass(declaration, strict) {
+    const results = [];
+    if (!declaration.parameterList ||
+        declaration.parameterList.nodeKind !== NodeKind.PARAMETER_LIST) {
+        return results;
+    }
+    const parameterList = declaration.parameterList;
+    const classBodyIdentifiers = new Set();
+    for (const statement of declaration.statements) {
+        for (const name of collectAllIdentifiers(statement)) {
+            classBodyIdentifiers.add(name);
+        }
+    }
+    for (const param of parameterList.parameters) {
+        if (param.nodeKind !== NodeKind.PARAMETER) {
+            continue;
+        }
+        const parameter = param;
+        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.",
+                location: identifier.startToken.getLocation(),
+            });
+        }
+    }
+    return results;
+}
+function checkClassIdNotInValidRangeOfBaseClass(declaration, symbolTable) {
+    const results = [];
+    if (!isExtendsModifier(declaration.extendsModifier)) {
+        return results;
+    }
+    const extendsModifier = declaration.extendsModifier;
+    if (!isIdentifier(extendsModifier.identifier)) {
+        return results;
+    }
+    const baseClassSymbol = symbolTable.lookupClass(extendsModifier.identifier.name);
+    if (!baseClassSymbol) {
+        return results;
+    }
+    const baseClass = baseClassSymbol.node;
+    if (!isBitModifier(baseClass.bitModifier)) {
+        return results;
+    }
+    if (!isBitModifier(declaration.bitModifier)) {
+        return results;
+    }
+    const baseBitModifier = baseClass.bitModifier;
+    const thisBitModifier = declaration.bitModifier;
+    if (baseBitModifier.classId.classIdKind === ClassIdKind.RANGE) {
+        const baseRange = baseBitModifier.classId;
+        const baseStartClassId = baseRange.startClassId;
+        const baseEndClassId = baseRange.endClassId;
+        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.classIdKind === ClassIdKind.SINGLE) {
+                const thisClassId = thisBitModifier.classId;
+                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.classIdKind === ClassIdKind.RANGE) {
+                const thisRange = thisBitModifier.classId;
+                const thisStartClassId = thisRange.startClassId;
+                const thisEndClassId = thisRange.endClassId;
+                const thisMin = isNumberLiteral(thisStartClassId.value)
+                    ? thisStartClassId.value.value
+                    : null;
+                const thisMax = isNumberLiteral(thisEndClassId.value) ? thisEndClassId.value.value : null;
+                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.",
+                        location: thisBitModifier.startToken.getLocation(),
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+function checkCannotExtendItself(declaration) {
+    const results = [];
+    if (!isExtendsModifier(declaration.extendsModifier)) {
+        return results;
+    }
+    const extendsModifier = declaration.extendsModifier;
+    if (!isIdentifier(extendsModifier.identifier) || !isIdentifier(declaration.identifier)) {
+        return results;
+    }
+    if (extendsModifier.identifier.name === declaration.identifier.name) {
+        results.push({
+            message: "A class cannot extend itself.",
+            location: extendsModifier.identifier.startToken.getLocation(),
+        });
+    }
+    return results;
+}
+function checkCannotRecursivelyContainItself(declaration) {
+    const results = [];
+    if (!isIdentifier(declaration.identifier)) {
+        return results;
+    }
+    const className = declaration.identifier.name;
+    function checkRecursive(statements) {
+        for (const statement of statements) {
+            if (statement.nodeKind === NodeKind.STATEMENT &&
+                statement.statementKind ===
+                    StatementKind.CLASS_DEFINITION) {
+                const classDef = statement;
+                if (isIdentifier(classDef.classIdentifier) && classDef.classIdentifier.name === className) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    if (checkRecursive(declaration.statements)) {
+        results.push({
+            message: "A class cannot recursively contain itself as a member.",
+            location: declaration.identifier.startToken.getLocation(),
+        });
+    }
+    return results;
+}
+function checkExpandableCannotExtendExpandable(declaration, symbolTable) {
+    const results = [];
+    if (!isExpandableModifier(declaration.expandableModifier)) {
+        return results;
+    }
+    if (!isExtendsModifier(declaration.extendsModifier)) {
+        return results;
+    }
+    const extendsModifier = declaration.extendsModifier;
+    if (!isIdentifier(extendsModifier.identifier)) {
+        return results;
+    }
+    const baseClassSymbol = symbolTable.lookupClass(extendsModifier.identifier.name);
+    if (!baseClassSymbol) {
+        return results;
+    }
+    const baseClass = baseClassSymbol.node;
+    if (isExpandableModifier(baseClass.expandableModifier)) {
+        results.push({
+            message: "An expandable class cannot extend an expandable class.",
+            location: declaration.expandableModifier.startToken.getLocation(),
+        });
+    }
+    return results;
+}
+function checkAlignmentMustMatchBaseClass(declaration, symbolTable) {
+    const results = [];
+    if (!isExtendsModifier(declaration.extendsModifier)) {
+        return results;
+    }
+    const extendsModifier = declaration.extendsModifier;
+    if (!isIdentifier(extendsModifier.identifier)) {
+        return results;
+    }
+    const identifier = extendsModifier.identifier;
+    const baseClassSymbol = symbolTable.lookupClass(identifier.name);
+    if (!baseClassSymbol) {
+        return results;
+    }
+    const baseClass = baseClassSymbol.node;
+    if (isAlignedModifier(declaration.alignedModifier)) {
+        if (isAlignedModifier(baseClass.alignedModifier)) {
+            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.",
+                    location: identifier.startToken.getLocation(),
+                });
+            }
+        }
+    }
+    else if (!isAlignedModifier(baseClass.alignedModifier)) {
+        return results;
+    }
+    const location = identifier.startToken.getLocation();
+    results.push({
+        message: "The alignment of a class which extends another must not differ from the alignment of the base class.",
+        location,
+    });
+    return results;
+}
+export const checkClassDeclaration = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.CLASS_DECLARATION,
+    checkFunc: function (declaration, symbolTable, strict) {
+        const results = [];
+        results.push(...checkMaxClassSizePositiveInteger(declaration));
+        results.push(...checkExpandableCannotBeAbstract(declaration));
+        results.push(...checkParameterReferencedWithinClass(declaration, strict));
+        results.push(...checkClassIdNotInValidRangeOfBaseClass(declaration, symbolTable));
+        results.push(...checkCannotExtendItself(declaration));
+        results.push(...checkCannotRecursivelyContainItself(declaration));
+        results.push(...checkExpandableCannotExtendExpandable(declaration, symbolTable));
+        results.push(...checkAlignmentMustMatchBaseClass(declaration, symbolTable));
+        return results;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkComputedArrayDefinition: Check;
+//# sourceMappingURL=check-computed-array-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-computed-array-definition.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-computed-array-definition.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,4BAA4B,EAAE,KAyB1C,CAAC"}

package/dist/src/analyser/checks/check-computed-array-definition.js

@@ -0,0 +1,29 @@
+import { ArrayDimensionKind } from "../../ast/node/enum/array-dimension-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { NumberLiteralKind } from "../../ast/node/enum/number-literal-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isNumberLiteral } from "../../ast/util/types.js";
+export const checkComputedArrayDefinition = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.COMPUTED_ARRAY_DEFINITION,
+    checkFunc: function (definition, _symbolTable, _strict) {
+        const results = [];
+        for (const dimension of definition.dimensions) {
+            if (dimension.nodeKind === NodeKind.ARRAY_DIMENSION) {
+                const explicitDimension = dimension;
+                if (explicitDimension.arrayDimensionKind === ArrayDimensionKind.EXPLICIT) {
+                    const size = explicitDimension.size;
+                    if (isNumberLiteral(size)) {
+                        if (size.value <= 0 || size.numberLiteralKind !== NumberLiteralKind.INTEGER) {
+                            results.push({
+                                message: "Array dimensions must be a positive integer.",
+                                location: size.startToken.getLocation(),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        return results;
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkComputedElementaryTypeDefinition: Check;
+//# sourceMappingURL=check-computed-elementary-type-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-computed-elementary-type-definition.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-computed-elementary-type-definition.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAErD,eAAO,MAAM,qCAAqC,EAAE,KAgCnD,CAAC"}

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

@@ -0,0 +1,27 @@
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { getRequiredIdentifier } from "../util/symbol-table-utils.js";
+export const checkComputedElementaryTypeDefinition = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
+    checkFunc: function (definition, symbolTable, strict) {
+        if (definition.value !== undefined) {
+            return [];
+        }
+        const identifier = getRequiredIdentifier(definition.identifier, definition, strict);
+        if (!identifier) {
+            return [];
+        }
+        // get the symbol using the identifier.name
+        const symbol = symbolTable.lookupVariable(identifier.name);
+        if (!symbol || !symbol.attributes.isConst) {
+            return [];
+        }
+        return [
+            {
+                message: `${identifier.name}: const computed elementary type definition must have a value specified`,
+                location: identifier.startToken.getLocation(),
+            },
+        ];
+    },
+};

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

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkElementaryTypeDefinition: Check;
+//# sourceMappingURL=check-elementary-type-definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"check-elementary-type-definition.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-elementary-type-definition.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAqIrD,eAAO,MAAM,6BAA6B,EAAE,KAkB3C,CAAC"}

package/dist/src/analyser/checks/check-elementary-type-definition.js

@@ -0,0 +1,121 @@
+import { ElementaryTypeKind } from "../../ast/node/enum/elementary-type-kind.js";
+import { NodeKind } from "../../ast/node/enum/node-kind.js";
+import { StatementKind } from "../../ast/node/enum/statement-kind.js";
+import { isNumberLiteral } from "../../ast/util/types.js";
+import { getElementaryTypeKind, getRequiredElementaryType } from "../util/symbol-table-utils.js";
+function checkOptionalCannotDefineRange(definition) {
+    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 [];
+}
+function checkRangeMinMaxValidation(definition) {
+    if (definition.value &&
+        definition.endValue &&
+        isNumberLiteral(definition.value) &&
+        isNumberLiteral(definition.endValue)) {
+        const minValue = definition.value;
+        const maxValue = definition.endValue;
+        // Check that types match
+        if (minValue.numberLiteralKind !== maxValue.numberLiteralKind) {
+            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,
+                    },
+                ];
+            }
+        }
+        // Check that max >= min
+        if (maxValue.value < minValue.value) {
+            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 [];
+}
+function checkValueRepresentability(definition, strict) {
+    const elementaryType = getRequiredElementaryType(definition.elementaryType, definition, strict);
+    if (!elementaryType) {
+        return [];
+    }
+    const elementaryTypeKind = getElementaryTypeKind(elementaryType, strict);
+    if (elementaryTypeKind === undefined) {
+        return [];
+    }
+    // Get bit width from length attribute
+    if (!definition.lengthAttribute ||
+        definition.lengthAttribute.nodeKind !== NodeKind.LENGTH_ATTRIBUTE) {
+        return [];
+    }
+    const lengthAttribute = definition.lengthAttribute;
+    if (!isNumberLiteral(lengthAttribute.length)) {
+        return [];
+    }
+    const lengthLiteral = lengthAttribute.length;
+    const bitWidth = lengthLiteral.value;
+    // Check if value is a NumberLiteral
+    if (definition.value && isNumberLiteral(definition.value)) {
+        const valueLiteral = definition.value;
+        const value = valueLiteral.value;
+        let isValid = false;
+        switch (elementaryTypeKind) {
+            case ElementaryTypeKind.UNSIGNED_INTEGER:
+            case ElementaryTypeKind.BIT:
+                isValid = value >= 0 && value < Math.pow(2, bitWidth);
+                break;
+            case ElementaryTypeKind.INTEGER: {
+                const minSigned = -Math.pow(2, bitWidth - 1);
+                const maxSigned = Math.pow(2, bitWidth - 1);
+                isValid = value >= minSigned && value < maxSigned;
+                break;
+            }
+            case ElementaryTypeKind.FLOATING_POINT:
+                isValid = true;
+                break;
+            default:
+                isValid = false;
+                break;
+        }
+        if (!isValid) {
+            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 [];
+}
+export const checkElementaryTypeDefinition = {
+    nodeKind: NodeKind.STATEMENT,
+    subKind: StatementKind.ELEMENTARY_TYPE_DEFINITION,
+    checkFunc: function (definition, _symbolTable, strict) {
+        const results = [];
+        results.push(...checkOptionalCannotDefineRange(definition));
+        results.push(...checkRangeMinMaxValidation(definition));
+        results.push(...checkValueRepresentability(definition, strict));
+        return results;
+    },
+};

package/dist/src/analyser/checks/check-expression-binary.d.ts

@@ -0,0 +1,3 @@
+import type { Check } from "./check.ts";
+export declare const checkExpressionBinary: Check;
+//# sourceMappingURL=check-expression-binary.d.ts.map

package/dist/src/analyser/checks/check-expression-binary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-expression-binary.d.ts","sourceRoot":"","sources":["../../../../src/analyser/checks/check-expression-binary.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,KAAK,EAAe,MAAM,YAAY,CAAC;AAiNrD,eAAO,MAAM,qBAAqB,EAAE,KA4BnC,CAAC"}