qasm-ts 2.1.2 → 2.1.4

package/dist/errors.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Error classes for QASM parsing and validation
+ *
+ * This module provides specific error types for different parsing failures,
+ * enabling precise error handling and debugging. Each error includes contextual
+ * information about where the error occurred in the source code.
+ *
+ * @module Error Handling
+ */
+/** Class representing a bad argument exception. */
+declare class BadArgumentError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad include statement */
+declare class BadIncludeError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad quantum register exception. */
+declare class BadQregError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad equality exception. */
+declare class BadEqualsError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad classical register exception. */
+declare class BadCregError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad conditional exception. */
+declare class BadConditionalError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad barrier exception. */
+declare class BadBarrierError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad measurement exception. */
+declare class BadMeasurementError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad gate exception. */
+declare class BadGateError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad parameter exception. */
+declare class BadParameterError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a missing semicolon exception. */
+declare class MissingSemicolonError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a missing opening or closing parenthesis, bracket, or curly brakcet. */
+declare class MissingBraceError extends Error {
+    constructor(message?: string);
+}
+/** Class representing an unsupported OpenQASM version exception. */
+declare class UnsupportedOpenQASMVersionError extends Error {
+    constructor(message?: string);
+}
+/** Class representing an error parsing an expected string literal. */
+declare class BadStringLiteralError extends Error {
+    constructor(message?: string);
+}
+/** Class representing an error parsing scalar types. */
+declare class BadClassicalTypeError extends Error {
+    constructor(message?: string);
+}
+/** Class representing an error parsing an expression. */
+declare class BadExpressionError extends Error {
+    constructor(message?: string);
+}
+/** Class representing an error in defining or calling a custom subroutine. */
+declare class BadSubroutineError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad loop statement declaration. */
+declare class BadLoopError extends Error {
+    constructor(message?: string);
+}
+/** Class representing a bad quantum instruction. */
+declare class BadQuantumInstructionError extends Error {
+    constructor(message?: string);
+}
+/** Type for returning an error constructor. */
+type ReturnErrorConstructor = new (message?: string) => Error;
+export { BadArgumentError, BadIncludeError, BadCregError, BadQregError, BadConditionalError, BadBarrierError, BadMeasurementError, BadGateError, BadEqualsError, BadParameterError, MissingSemicolonError, MissingBraceError, UnsupportedOpenQASMVersionError, BadStringLiteralError, BadClassicalTypeError, BadExpressionError, BadSubroutineError, BadLoopError, BadQuantumInstructionError, ReturnErrorConstructor, };

package/dist/errors.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Error classes for QASM parsing and validation
  *
@@ -8,267 +7,156 @@
  *
  * @module Error Handling
  */
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BadQuantumInstructionError = exports.BadLoopError = exports.BadSubroutineError = exports.BadExpressionError = exports.BadClassicalTypeError = exports.BadStringLiteralError = exports.UnsupportedOpenQASMVersionError = exports.MissingBraceError = exports.MissingSemicolonError = exports.BadParameterError = exports.BadEqualsError = exports.BadGateError = exports.BadMeasurementError = exports.BadBarrierError = exports.BadConditionalError = exports.BadQregError = exports.BadCregError = exports.BadIncludeError = exports.BadArgumentError = void 0;
 /** Class representing a bad argument exception. */
-var BadArgumentError = /** @class */ (function (_super) {
-    __extends(BadArgumentError, _super);
-    function BadArgumentError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadArgumentError.name;
-        return _this;
+class BadArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadArgumentError.name;
     }
-    return BadArgumentError;
-}(Error));
-exports.BadArgumentError = BadArgumentError;
+}
 /** Class representing a bad include statement */
-var BadIncludeError = /** @class */ (function (_super) {
-    __extends(BadIncludeError, _super);
-    function BadIncludeError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadIncludeError.name;
-        return _this;
+class BadIncludeError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadIncludeError.name;
     }
-    return BadIncludeError;
-}(Error));
-exports.BadIncludeError = BadIncludeError;
+}
 /** Class representing a bad quantum register exception. */
-var BadQregError = /** @class */ (function (_super) {
-    __extends(BadQregError, _super);
-    function BadQregError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadQregError.name;
-        return _this;
+class BadQregError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadQregError.name;
     }
-    return BadQregError;
-}(Error));
-exports.BadQregError = BadQregError;
+}
 /** Class representing a bad equality exception. */
-var BadEqualsError = /** @class */ (function (_super) {
-    __extends(BadEqualsError, _super);
-    function BadEqualsError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadEqualsError.name;
-        return _this;
+class BadEqualsError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadEqualsError.name;
     }
-    return BadEqualsError;
-}(Error));
-exports.BadEqualsError = BadEqualsError;
+}
 /** Class representing a bad classical register exception. */
-var BadCregError = /** @class */ (function (_super) {
-    __extends(BadCregError, _super);
-    function BadCregError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadCregError.name;
-        return _this;
+class BadCregError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadCregError.name;
     }
-    return BadCregError;
-}(Error));
-exports.BadCregError = BadCregError;
+}
 /** Class representing a bad conditional exception. */
-var BadConditionalError = /** @class */ (function (_super) {
-    __extends(BadConditionalError, _super);
-    function BadConditionalError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadConditionalError.name;
-        return _this;
+class BadConditionalError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadConditionalError.name;
     }
-    return BadConditionalError;
-}(Error));
-exports.BadConditionalError = BadConditionalError;
+}
 /** Class representing a bad barrier exception. */
-var BadBarrierError = /** @class */ (function (_super) {
-    __extends(BadBarrierError, _super);
-    function BadBarrierError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadBarrierError.name;
-        return _this;
+class BadBarrierError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadBarrierError.name;
     }
-    return BadBarrierError;
-}(Error));
-exports.BadBarrierError = BadBarrierError;
+}
 /** Class representing a bad measurement exception. */
-var BadMeasurementError = /** @class */ (function (_super) {
-    __extends(BadMeasurementError, _super);
-    function BadMeasurementError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadMeasurementError.name;
-        return _this;
+class BadMeasurementError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadMeasurementError.name;
     }
-    return BadMeasurementError;
-}(Error));
-exports.BadMeasurementError = BadMeasurementError;
+}
 /** Class representing a bad gate exception. */
-var BadGateError = /** @class */ (function (_super) {
-    __extends(BadGateError, _super);
-    function BadGateError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadGateError.name;
-        return _this;
+class BadGateError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadGateError.name;
     }
-    return BadGateError;
-}(Error));
-exports.BadGateError = BadGateError;
+}
 /** Class representing a bad parameter exception. */
-var BadParameterError = /** @class */ (function (_super) {
-    __extends(BadParameterError, _super);
-    function BadParameterError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadParameterError.name;
-        return _this;
+class BadParameterError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadParameterError.name;
     }
-    return BadParameterError;
-}(Error));
-exports.BadParameterError = BadParameterError;
+}
 /** Class representing a missing semicolon exception. */
-var MissingSemicolonError = /** @class */ (function (_super) {
-    __extends(MissingSemicolonError, _super);
-    function MissingSemicolonError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = MissingSemicolonError.name;
-        return _this;
+class MissingSemicolonError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = MissingSemicolonError.name;
     }
-    return MissingSemicolonError;
-}(Error));
-exports.MissingSemicolonError = MissingSemicolonError;
+}
 /** Class representing a missing opening or closing parenthesis, bracket, or curly brakcet. */
-var MissingBraceError = /** @class */ (function (_super) {
-    __extends(MissingBraceError, _super);
-    function MissingBraceError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = MissingSemicolonError.name;
-        return _this;
+class MissingBraceError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = MissingSemicolonError.name;
     }
-    return MissingBraceError;
-}(Error));
-exports.MissingBraceError = MissingBraceError;
+}
 /** Class representing an unsupported OpenQASM version exception. */
-var UnsupportedOpenQASMVersionError = /** @class */ (function (_super) {
-    __extends(UnsupportedOpenQASMVersionError, _super);
-    function UnsupportedOpenQASMVersionError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = UnsupportedOpenQASMVersionError.name;
-        return _this;
+class UnsupportedOpenQASMVersionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = UnsupportedOpenQASMVersionError.name;
     }
-    return UnsupportedOpenQASMVersionError;
-}(Error));
-exports.UnsupportedOpenQASMVersionError = UnsupportedOpenQASMVersionError;
+}
 /** Class representing an error parsing an expected string literal. */
-var BadStringLiteralError = /** @class */ (function (_super) {
-    __extends(BadStringLiteralError, _super);
-    function BadStringLiteralError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadStringLiteralError.name;
-        return _this;
+class BadStringLiteralError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadStringLiteralError.name;
     }
-    return BadStringLiteralError;
-}(Error));
-exports.BadStringLiteralError = BadStringLiteralError;
+}
 /** Class representing an error parsing scalar types. */
-var BadClassicalTypeError = /** @class */ (function (_super) {
-    __extends(BadClassicalTypeError, _super);
-    function BadClassicalTypeError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadClassicalTypeError.name;
-        return _this;
+class BadClassicalTypeError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadClassicalTypeError.name;
     }
-    return BadClassicalTypeError;
-}(Error));
-exports.BadClassicalTypeError = BadClassicalTypeError;
+}
 /** Class representing an error parsing an expression. */
-var BadExpressionError = /** @class */ (function (_super) {
-    __extends(BadExpressionError, _super);
-    function BadExpressionError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadExpressionError.name;
-        return _this;
+class BadExpressionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadExpressionError.name;
     }
-    return BadExpressionError;
-}(Error));
-exports.BadExpressionError = BadExpressionError;
+}
 /** Class representing an error in defining or calling a custom subroutine. */
-var BadSubroutineError = /** @class */ (function (_super) {
-    __extends(BadSubroutineError, _super);
-    function BadSubroutineError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadSubroutineError.name;
-        return _this;
+class BadSubroutineError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadSubroutineError.name;
     }
-    return BadSubroutineError;
-}(Error));
-exports.BadSubroutineError = BadSubroutineError;
+}
 /** Class representing a bad loop statement declaration. */
-var BadLoopError = /** @class */ (function (_super) {
-    __extends(BadLoopError, _super);
-    function BadLoopError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadLoopError.name;
-        return _this;
+class BadLoopError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadLoopError.name;
     }
-    return BadLoopError;
-}(Error));
-exports.BadLoopError = BadLoopError;
+}
 /** Class representing a bad quantum instruction. */
-var BadQuantumInstructionError = /** @class */ (function (_super) {
-    __extends(BadQuantumInstructionError, _super);
-    function BadQuantumInstructionError(message) {
-        var _newTarget = this.constructor;
-        var _this = _super.call(this, message) || this;
-        Object.setPrototypeOf(_this, _newTarget.prototype);
-        _this.name = BadQuantumInstructionError.name;
-        return _this;
-    }
-    return BadQuantumInstructionError;
-}(Error));
-exports.BadQuantumInstructionError = BadQuantumInstructionError;
+class BadQuantumInstructionError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        this.name = BadQuantumInstructionError.name;
+    }
+}
+export { BadArgumentError, BadIncludeError, BadCregError, BadQregError, BadConditionalError, BadBarrierError, BadMeasurementError, BadGateError, BadEqualsError, BadParameterError, MissingSemicolonError, MissingBraceError, UnsupportedOpenQASMVersionError, BadStringLiteralError, BadClassicalTypeError, BadExpressionError, BadSubroutineError, BadLoopError, BadQuantumInstructionError, };

package/dist/lexer.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Main lexer interface for tokenizing QASM code
+ *
+ * The lexer is responsible for breaking down QASM source code into tokens
+ * that can be consumed by the parser. It supports both OpenQASM 2.0 and 3.0
+ * syntax, with version-specific lexers handling the differences in token types
+ * and syntax rules.
+ *
+ * The specific Lexer implementations can be found at:
+ * - {@link Qasm3Lexer}
+ * - {@link Qasm2Lexer}
+ *
+ * @module Lexing
+ *
+ * @example Token Flow
+ * ```
+ * Source Code → Lexer → Tokens → Parser → AST
+ * "h q[0];"  →  [Id, Id, LSParen, NNInteger, RSParen, Semicolon]
+ * ```
+ *
+ *  * @example Basic lexing workflow
+ * ```typescript
+ * import { lex } from './lexer';
+ *
+ * const qasmCode = 'OPENQASM 3.0; qubit q; h q;';
+ * const tokens = lex(qasmCode);
+ * console.log(tokens);
+ * // [
+ * //   [Token.OpenQASM, undefined],
+ * //   [Token.Id, 'qubit'],
+ * //   [Token.Id, 'q'],
+ * //   [Token.Semicolon, undefined],
+ * //   [Token.Id, 'h'],
+ * //   [Token.Id, 'q'],
+ * //   [Token.Semicolon, undefined]
+ * // ]
+ * ```
+ */
+import { Token as Qasm2Token } from "./qasm2/token";
+import { Token as Qasm3Token } from "./qasm3/token";
+import { OpenQASMVersion, OpenQASMMajorVersion } from "./version";
+/**
+ * Tokenizes OpenQASM source code into an array of tokens.
+ *
+ * This is the main entry point for lexical analysis. It automatically selects
+ * the appropriate lexer implementation based on the OpenQASM version and returns
+ * an array of tokens that can be consumed by the parser.
+ *
+ * Each token is represented as a tuple containing:
+ * - **Token type**: An enum value indicating the kind of token
+ * - **Token value**: The associated value (for literals, identifiers, operators)
+ *
+ * @group Lexing
+ * @param qasm - The OpenQASM source code to tokenize
+ * @param cursor - Starting position in the input string (defaults to 0)
+ * @param version - OpenQASM version to use for lexing (defaults to 3.0)
+ * @returns Array of token tuples [TokenType, value?]
+ * @throws {UnsupportedOpenQASMVersionError} When an unsupported version is specified
+ *
+ * @example Tokenize OpenQASM 3.0 code
+ * ```typescript
+ * const tokens = lex('qubit[2] q; h q[0];', 0, 3);
+ * // Returns tokens using OpenQASM 3.0 syntax rules
+ * ```
+ *
+ * @example Tokenize OpenQASM 2.0 code
+ * ```typescript
+ * const tokens = lex('qreg q[2]; h q[0];', 0, 2);
+ * // Returns tokens using OpenQASM 2.0 syntax rules
+ * ```
+ *
+ * @example Resume lexing from specific position
+ * ```typescript
+ * const code = 'OPENQASM 3.0; qubit q;';
+ * const tokens = lex(code, 12); // Start after "OPENQASM 3.0"
+ * ```
+ */
+export declare function lex(qasm: string, cursor?: number, version?: OpenQASMVersion | OpenQASMMajorVersion | number): Array<[Qasm2Token | Qasm3Token, (number | string)?]>;

package/dist/lexer.js

@@ -1,4 +1,3 @@
-"use strict";
 /**
  * Main lexer interface for tokenizing QASM code
  *
@@ -37,12 +36,10 @@
  * // ]
  * ```
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.lex = lex;
-var lexer_1 = require("./qasm2/lexer");
-var lexer_2 = require("./qasm3/lexer");
-var version_1 = require("./version");
-var errors_1 = require("./errors");
+import { default as Qasm2Lexer } from "./qasm2/lexer";
+import { default as Qasm3Lexer } from "./qasm3/lexer";
+import { OpenQASMVersion, OpenQASMMajorVersion } from "./version";
+import { UnsupportedOpenQASMVersionError } from "./errors";
 /**
  * Tokenizes OpenQASM source code into an array of tokens.
  *
@@ -79,41 +76,41 @@ var errors_1 = require("./errors");
  * const tokens = lex(code, 12); // Start after "OPENQASM 3.0"
  * ```
  */
-function lex(qasm, cursor, version) {
-    var lexer;
-    if (version instanceof version_1.OpenQASMVersion) {
+export function lex(qasm, cursor, version) {
+    let lexer;
+    if (version instanceof OpenQASMVersion) {
         switch (version.major) {
-            case version_1.OpenQASMMajorVersion.Version2:
-                lexer = new lexer_1.default(qasm, cursor);
+            case OpenQASMMajorVersion.Version2:
+                lexer = new Qasm2Lexer(qasm, cursor);
                 break;
-            case version_1.OpenQASMMajorVersion.Version3:
-                lexer = new lexer_2.default(qasm, cursor);
+            case OpenQASMMajorVersion.Version3:
+                lexer = new Qasm3Lexer(qasm, cursor);
                 break;
             default:
-                throw new errors_1.UnsupportedOpenQASMVersionError("Unsupported OpenQASM version detected: ".concat(version.major));
+                throw new UnsupportedOpenQASMVersionError(`Unsupported OpenQASM version detected: ${version.major}`);
         }
     }
     else if (typeof version === "number") {
         switch (version) {
             case 2:
-                lexer = new lexer_1.default(qasm, cursor);
+                lexer = new Qasm2Lexer(qasm, cursor);
                 break;
             case 3:
-                lexer = new lexer_2.default(qasm, cursor);
+                lexer = new Qasm3Lexer(qasm, cursor);
                 break;
             default:
-                throw new errors_1.UnsupportedOpenQASMVersionError("Unsupported OpenQASM version detected: ".concat(version));
+                throw new UnsupportedOpenQASMVersionError(`Unsupported OpenQASM version detected: ${version}`);
         }
     }
-    else if (version === version_1.OpenQASMMajorVersion.Version2) {
-        lexer = new lexer_1.default(qasm, cursor);
+    else if (version === OpenQASMMajorVersion.Version2) {
+        lexer = new Qasm2Lexer(qasm, cursor);
     }
-    else if (version === version_1.OpenQASMMajorVersion.Version3) {
-        lexer = new lexer_2.default(qasm, cursor);
+    else if (version === OpenQASMMajorVersion.Version3) {
+        lexer = new Qasm3Lexer(qasm, cursor);
     }
     else {
-        lexer = new lexer_2.default(qasm, cursor);
+        lexer = new Qasm3Lexer(qasm, cursor);
     }
-    var tokens = lexer.lex();
+    const tokens = lexer.lex();
     return tokens;
 }