qasm-ts 1.1.3 → 2.1.0

package/dist/qasm3/token.js

@@ -0,0 +1,425 @@
+"use strict";
+/**
+ * OpenQASM 3.0 Token Definitions and Utilities
+ *
+ * This module defines all the token types used in OpenQASM 3.0 syntax, which
+ * significantly extends OpenQASM 2.0 with modern programming language features.
+ *
+ * Major additions in OpenQASM 3.0:
+ * - **Classical types**: int, uint, float, bool, bit, complex
+ * - **Control flow**: if/else, for/while loops, switch/case
+ * - **Functions**: def, return, extern declarations
+ * - **Advanced features**: arrays, timing (delay, durationof), calibration
+ * - **Quantum extensions**: qubit declarations, gate modifiers, hardware qubits
+ *
+ * @module
+ *
+ * @example OpenQASM 3.0 advanced tokens
+ * ```typescript
+ * import { lookup, Token } from './qasm3/token';
+ *
+ * console.log(lookup('qubit'));    // Token.Qubit
+ * console.log(lookup('if'));       // Token.If
+ * console.log(lookup('def'));      // Token.Def
+ * console.log(lookup('complex'));  // Token.Complex
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Token = void 0;
+exports.notParam = notParam;
+exports.lookup = lookup;
+exports.inverseLookup = inverseLookup;
+/**
+ * Enumeration of all OpenQASM 3.0 token types.
+ *
+ * Each token represents a specific syntactic element in OpenQASM 3.0 code.
+ * The enum values correspond to different categories:
+ * - Literals: NNInteger, Real, String, BoolLiteral
+ * - Identifiers: Id
+ * - Keywords: Qubit, Gate, Measure, If, For, While, etc.
+ * - Operators: ArithmeticOp, BinaryOp, UnaryOp
+ * - Punctuation: Semicolon, Comma, LParen, RParen, etc.
+ * - Special: OpenQASM, Include, EndOfFile, Illegal
+ */
+var Token;
+(function (Token) {
+    // 0; invalid or unrecognized token
+    Token[Token["Illegal"] = 0] = "Illegal";
+    // 1; end of file character
+    Token[Token["EndOfFile"] = 1] = "EndOfFile";
+    // 2; real number (floating point)
+    Token[Token["Real"] = 2] = "Real";
+    // 3; non-negative integer
+    Token[Token["NNInteger"] = 3] = "NNInteger";
+    // 4; integer that supports underscores and negatives
+    Token[Token["Integer"] = 4] = "Integer";
+    // 5; identifier (variables names, function names, etc.)
+    Token[Token["Id"] = 5] = "Id";
+    // 6; OPENQASM version declaration
+    Token[Token["OpenQASM"] = 6] = "OpenQASM";
+    // 7; include statement
+    Token[Token["Include"] = 7] = "Include";
+    // 8; semicolon to terminate statements
+    Token[Token["Semicolon"] = 8] = "Semicolon";
+    // 9; colon
+    Token[Token["Colon"] = 9] = "Colon";
+    // 10; comma
+    Token[Token["Comma"] = 10] = "Comma";
+    // 11; left paren (
+    Token[Token["LParen"] = 11] = "LParen";
+    // 12; left square bracket [
+    Token[Token["LSParen"] = 12] = "LSParen";
+    // 13; left curly brakcet {
+    Token[Token["LCParen"] = 13] = "LCParen";
+    // 14; right paren )
+    Token[Token["RParen"] = 14] = "RParen";
+    // 15; right square paren ]
+    Token[Token["RSParen"] = 15] = "RSParen";
+    // 16; right curly bracket }
+    Token[Token["RCParen"] = 16] = "RCParen";
+    // 17; assignment operator (=)
+    Token[Token["EqualsAssmt"] = 17] = "EqualsAssmt";
+    // 18; arrow (->) used in measurement operations
+    Token[Token["Arrow"] = 18] = "Arrow";
+    // 19; quantum register declaration
+    Token[Token["QReg"] = 19] = "QReg";
+    // 20; quantum register declaration (functionally equivalent to QReg but for OpenQASM version 3)
+    Token[Token["Qubit"] = 20] = "Qubit";
+    // 21; classical register declaration
+    Token[Token["CReg"] = 21] = "CReg";
+    // 22; classical register declaration (functionally equivalent to Creg but for OpenQASM version 3)
+    Token[Token["Bit"] = 22] = "Bit";
+    // 23; barrier operation
+    Token[Token["Barrier"] = 23] = "Barrier";
+    // 24; gate declaration or application
+    Token[Token["Gate"] = 24] = "Gate";
+    // 25; measurement operation
+    Token[Token["Measure"] = 25] = "Measure";
+    // 26; qubit reset operation
+    Token[Token["Reset"] = 26] = "Reset";
+    // 27; string literal
+    Token[Token["String"] = 27] = "String";
+    // 28; opaque keyword
+    Token[Token["Opaque"] = 28] = "Opaque";
+    // 29; defcalgrammar keyword
+    Token[Token["DefcalGrammar"] = 29] = "DefcalGrammar";
+    // 30; float type keyword
+    Token[Token["Float"] = 30] = "Float";
+    // 31; bool type keyword,
+    Token[Token["Bool"] = 31] = "Bool";
+    // 32; int type keyword
+    Token[Token["Int"] = 32] = "Int";
+    // 33; uint type keyword
+    Token[Token["UInt"] = 33] = "UInt";
+    // 34; mathematical constant pi
+    Token[Token["Pi"] = 34] = "Pi";
+    // 35; euler constant
+    Token[Token["Euler"] = 35] = "Euler";
+    // 36; tau constant
+    Token[Token["Tau"] = 36] = "Tau";
+    // 37; binary literal
+    Token[Token["BinaryLiteral"] = 37] = "BinaryLiteral";
+    // 38; octal literal
+    Token[Token["OctalLiteral"] = 38] = "OctalLiteral";
+    // 39; hex literal
+    Token[Token["HexLiteral"] = 39] = "HexLiteral";
+    // 40; arithmetic operators
+    Token[Token["ArithmeticOp"] = 40] = "ArithmeticOp";
+    // 41; compound arithmetic operators
+    Token[Token["CompoundArithmeticOp"] = 41] = "CompoundArithmeticOp";
+    // 42; boolean literal value
+    Token[Token["BoolLiteral"] = 42] = "BoolLiteral";
+    // 43; duration keyword
+    Token[Token["Duration"] = 43] = "Duration";
+    // 44; unary operator
+    Token[Token["UnaryOp"] = 44] = "UnaryOp";
+    // 45; binary operator
+    Token[Token["BinaryOp"] = 45] = "BinaryOp";
+    // 46; let keyword for aliasing
+    Token[Token["Let"] = 46] = "Let";
+    // 47; quantum gate modifier
+    Token[Token["QuantumModifier"] = 47] = "QuantumModifier";
+    // 48; delay keyword
+    Token[Token["Delay"] = 48] = "Delay";
+    // 49; return keyword
+    Token[Token["Return"] = 49] = "Return";
+    // 50; def keyword for subroutines
+    Token[Token["Def"] = 50] = "Def";
+    // 51; for loop keyword
+    Token[Token["For"] = 51] = "For";
+    // 52; in keyword
+    Token[Token["In"] = 52] = "In";
+    // 53; while loop keyword
+    Token[Token["While"] = 53] = "While";
+    // 54; break keyword
+    Token[Token["Break"] = 54] = "Break";
+    // 55; continue keyword
+    Token[Token["Continue"] = 55] = "Continue";
+    // 56; input keyword
+    Token[Token["Input"] = 56] = "Input";
+    // 57; output keyword
+    Token[Token["Output"] = 57] = "Output";
+    // 58; switch statement keyword
+    Token[Token["Switch"] = 58] = "Switch";
+    // 59; switch case keyword
+    Token[Token["Case"] = 59] = "Case";
+    // 60; switch default keyword
+    Token[Token["Default"] = 60] = "Default";
+    // 61; defcal keyword
+    Token[Token["Defcal"] = 61] = "Defcal";
+    // 62; constant keywork
+    Token[Token["Const"] = 62] = "Const";
+    // 63; if statement conditional
+    Token[Token["If"] = 63] = "If";
+    // 64; else keyword
+    Token[Token["Else"] = 64] = "Else";
+    // 65; end keyword
+    Token[Token["End"] = 65] = "End";
+    // 66; inverse cosine
+    Token[Token["Arccos"] = 66] = "Arccos";
+    // 67; inverse sine
+    Token[Token["Arcsin"] = 67] = "Arcsin";
+    // 68; inverse tangent
+    Token[Token["Arctan"] = 68] = "Arctan";
+    // 69; ceiling function
+    Token[Token["Ceiling"] = 69] = "Ceiling";
+    // 70; cosine function
+    Token[Token["Cos"] = 70] = "Cos";
+    // 71; exp keyword
+    Token[Token["Exp"] = 71] = "Exp";
+    // 72; floor function
+    Token[Token["Floor"] = 72] = "Floor";
+    // 73; logarithm base e
+    Token[Token["Log"] = 73] = "Log";
+    // 74; modulus
+    Token[Token["Mod"] = 74] = "Mod";
+    // 75; popcount function
+    Token[Token["Popcount"] = 75] = "Popcount";
+    // 76; power function
+    Token[Token["Pow"] = 76] = "Pow";
+    // 77; rotate bits left function
+    Token[Token["Rotl"] = 77] = "Rotl";
+    // 78; rotate bits right function
+    Token[Token["Rotr"] = 78] = "Rotr";
+    // 79; sine
+    Token[Token["Sin"] = 79] = "Sin";
+    // 80; sqaure root
+    Token[Token["Sqrt"] = 80] = "Sqrt";
+    // 81; tangent
+    Token[Token["Tan"] = 81] = "Tan";
+    // 82; angle type
+    Token[Token["Angle"] = 82] = "Angle";
+    // 83; ctrl gate modifier
+    Token[Token["Ctrl"] = 83] = "Ctrl";
+    // 84; negctrl gate modifier
+    Token[Token["NegCtrl"] = 84] = "NegCtrl";
+    // 85; inv gate modifier
+    Token[Token["Inv"] = 85] = "Inv";
+    // 86; pow gate modifier
+    Token[Token["PowM"] = 86] = "PowM";
+    // 87; @ symbol
+    Token[Token["At"] = 87] = "At";
+    // 88; complex number keyword
+    Token[Token["Complex"] = 88] = "Complex";
+    // 89; $ symbol
+    Token[Token["Dollar"] = 89] = "Dollar";
+    // 90; array keyword
+    Token[Token["Array"] = 90] = "Array";
+    // 91; durationof function keyword
+    Token[Token["DurationOf"] = 91] = "DurationOf";
+    // 92; stretch type keyword
+    Token[Token["Stretch"] = 92] = "Stretch";
+    // 93; box keyword
+    Token[Token["Box"] = 93] = "Box";
+    // 94; readonly keyword
+    Token[Token["ReadOnly"] = 94] = "ReadOnly";
+    // 95; mutable keyword
+    Token[Token["Mutable"] = 95] = "Mutable";
+    // 96; #dim array dimensions
+    Token[Token["Dim"] = 96] = "Dim";
+    // 97; scientific notation literal
+    Token[Token["ScientificNotation"] = 97] = "ScientificNotation";
+    // 98; sizeof function
+    Token[Token["SizeOf"] = 98] = "SizeOf";
+    // 99; extern keyword
+    Token[Token["Extern"] = 99] = "Extern";
+    // 100; compound binary operators
+    Token[Token["CompoundBinaryOp"] = 100] = "CompoundBinaryOp";
+})(Token || (exports.Token = Token = {}));
+/**
+ * Mapping of string keywords to their corresponding token types.
+ *
+ * This lookup table enables the lexer to quickly determine if a string
+ * represents a reserved keyword or should be treated as an identifier.
+ *
+ * @internal
+ */
+var lookupMap = {
+    pi: Token.Pi,
+    π: Token.Pi,
+    qreg: Token.QReg,
+    qubit: Token.Qubit,
+    creg: Token.CReg,
+    bit: Token.Bit,
+    barrier: Token.Barrier,
+    gate: Token.Gate,
+    measure: Token.Measure,
+    reset: Token.Reset,
+    include: Token.Include,
+    if: Token.If,
+    opaque: Token.Opaque,
+    defcalgrammar: Token.DefcalGrammar,
+    float: Token.Float,
+    bool: Token.Bool,
+    true: Token.BoolLiteral,
+    false: Token.BoolLiteral,
+    int: Token.Int,
+    uint: Token.UInt,
+    euler: Token.Euler,
+    ℇ: Token.Euler,
+    tau: Token.Tau,
+    τ: Token.Tau,
+    duration: Token.Duration,
+    let: Token.Let,
+    delay: Token.Delay,
+    return: Token.Return,
+    def: Token.Def,
+    for: Token.For,
+    in: Token.In,
+    while: Token.While,
+    break: Token.Break,
+    continue: Token.Continue,
+    input: Token.Input,
+    output: Token.Output,
+    switch: Token.Switch,
+    case: Token.Case,
+    default: Token.Default,
+    defcal: Token.Defcal,
+    const: Token.Const,
+    else: Token.Else,
+    end: Token.End,
+    "!": Token.UnaryOp,
+    "~": Token.UnaryOp,
+    "**": Token.ArithmeticOp,
+    "*": Token.ArithmeticOp,
+    "/": Token.ArithmeticOp,
+    "%": Token.ArithmeticOp,
+    "+": Token.ArithmeticOp,
+    "++": Token.ArithmeticOp,
+    "&": Token.BinaryOp,
+    "|": Token.BinaryOp,
+    "^": Token.BinaryOp,
+    "&&": Token.BinaryOp,
+    "||": Token.BinaryOp,
+    "<": Token.BinaryOp,
+    "<=": Token.BinaryOp,
+    ">": Token.BinaryOp,
+    ">=": Token.BinaryOp,
+    "==": Token.BinaryOp,
+    "!=": Token.BinaryOp,
+    "<<": Token.BinaryOp,
+    ">>": Token.BinaryOp,
+    "**=": Token.CompoundArithmeticOp,
+    "/=": Token.CompoundArithmeticOp,
+    "%=": Token.CompoundArithmeticOp,
+    "+=": Token.CompoundArithmeticOp,
+    "-=": Token.CompoundArithmeticOp,
+    "*=": Token.CompoundArithmeticOp,
+    "^=": Token.CompoundArithmeticOp,
+    arccos: Token.Arccos,
+    arcsin: Token.Arcsin,
+    arctan: Token.Arctan,
+    ceiling: Token.Ceiling,
+    cos: Token.Cos,
+    exp: Token.Exp,
+    floor: Token.Floor,
+    log: Token.Log,
+    mod: Token.Mod,
+    popcount: Token.Popcount,
+    pow: Token.Pow,
+    rotl: Token.Rotl,
+    rotr: Token.Rotr,
+    sin: Token.Sin,
+    sqrt: Token.Sqrt,
+    tan: Token.Tan,
+    angle: Token.Angle,
+    "@": Token.At,
+    complex: Token.Complex,
+    $: Token.Dollar,
+    array: Token.Array,
+    durationof: Token.DurationOf,
+    stretch: Token.Stretch,
+    box: Token.Box,
+    readonly: Token.ReadOnly,
+    mutable: Token.Mutable,
+    sizeof: Token.SizeOf,
+    extern: Token.Extern,
+};
+/**
+ * Returns the token type that corresponds to a given string.
+ *
+ * This function is used by the lexer to classify identifiers and keywords.
+ * If the string is a reserved keyword, it returns the appropriate token type.
+ * Otherwise, it returns Token.Id to indicate a user-defined identifier.
+ *
+ * @param ident - The string to look up
+ * @returns The corresponding token type
+ *
+ * @example Keyword lookup
+ * ```typescript
+ * lookup('qubit');     // Returns Token.Qubit
+ * lookup('measure');   // Returns Token.Measure
+ * lookup('myVar');     // Returns Token.Id
+ * lookup('π');         // Returns Token.Pi
+ * ```
+ */
+function lookup(ident) {
+    return ident in lookupMap ? lookupMap[ident] : Token.Id;
+}
+/**
+ * Returns the string representation of a token type.
+ *
+ * This is useful for debugging and error reporting, allowing you to
+ * convert token enum values back to their string representations.
+ *
+ * @param token - The token type to convert
+ * @returns The string representation of the token, or undefined if not found
+ *
+ * @example Token to string conversion
+ * ```typescript
+ * inverseLookup(Token.Qubit);   // Returns 'qubit'
+ * inverseLookup(Token.If);      // Returns 'if'
+ * inverseLookup(Token.Pi);      // Returns 'pi'
+ * ```
+ */
+function inverseLookup(token) {
+    return Object.keys(lookupMap).find(function (ident) { return lookupMap[ident] == token; });
+}
+/**
+ * Determines whether a token can be used as a parameter in expressions.
+ *
+ * This function helps the parser validate parameter lists by checking if
+ * a token type is allowed in parameter contexts. Parameters can include
+ * identifiers, numbers, and other value-bearing tokens, but not structural
+ * tokens like semicolons or braces.
+ *
+ * @param token - The token type to check
+ * @returns true if the token CANNOT be used as a parameter, false otherwise
+ *
+ * @example Parameter validation
+ * ```typescript
+ * notParam(Token.Id);         // false - identifiers can be parameters
+ * notParam(Token.NNInteger);  // false - numbers can be parameters
+ * notParam(Token.Semicolon);  // true - semicolons cannot be parameters
+ * notParam(Token.LParen);     // true - parentheses cannot be parameters
+ * ```
+ */
+function notParam(token) {
+    if (token == Token.NNInteger ||
+        token == Token.Real ||
+        token == Token.Id ||
+        inverseLookup(token)) {
+        return false;
+    }
+    return true;
+}

package/dist/version.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * OpenQASM version detection and management utilities
+ *
+ * Handles version detection from QASM source code and provides utilities
+ * for working with different OpenQASM versions. Supports automatic version
+ * detection from OPENQASM statements and manual version specification.
+ *
+ * @module Version Management
+ *
+ * @example Version detection
+ * ```typescript
+ * const version = new OpenQASMVersion(3, 0);
+ * console.log(version.toString()); // "3.0"
+ * console.log(version.isVersion3()); // true
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenQASMVersion = exports.OpenQASMMajorVersion = void 0;
+/** Enum representing the major OpenQASM versions. */
+var OpenQASMMajorVersion;
+(function (OpenQASMMajorVersion) {
+    OpenQASMMajorVersion[OpenQASMMajorVersion["Version2"] = 2] = "Version2";
+    OpenQASMMajorVersion[OpenQASMMajorVersion["Version3"] = 3] = "Version3";
+})(OpenQASMMajorVersion || (exports.OpenQASMMajorVersion = OpenQASMMajorVersion = {}));
+/** Class representing the OpenQASM version. */
+var OpenQASMVersion = /** @class */ (function () {
+    /**
+     * Creates an OpenQASMVersion instance.
+     * @param major - The OpenQASM major version. (optional)
+     * @param minor - The OpenQASM minor version (optional)
+     */
+    function OpenQASMVersion(major, minor) {
+        this.major = major ? major : OpenQASMMajorVersion.Version3;
+        this.minor = minor ? minor : 0;
+    }
+    /** Returns the version as a formatted string. */
+    OpenQASMVersion.prototype.toString = function () {
+        return "".concat(this.major, ".").concat(this.minor);
+    };
+    /** Returns whether the version is 3.x */
+    OpenQASMVersion.prototype.isVersion3 = function () {
+        if (this.major === OpenQASMMajorVersion.Version3) {
+            return true;
+        }
+        return false;
+    };
+    /** Returns whether the version is 2.x */
+    OpenQASMVersion.prototype.isVersion2 = function () {
+        if (this.major === OpenQASMMajorVersion.Version2) {
+            return true;
+        }
+        return false;
+    };
+    return OpenQASMVersion;
+}());
+exports.OpenQASMVersion = OpenQASMVersion;

package/docs/assets/hierarchy.js

@@ -0,0 +1 @@
+window.hierarchyData = "eJyrVirKzy8pVrKKjtVRKkpNy0lNLsnMzwMKVNfWAgCbHgqm"

package/docs/custom.css

@@ -0,0 +1,3 @@
+.tsd-navigation.settings {
+  display: none !important;
+}

package/docs/docs-readme.md

@@ -0,0 +1,208 @@
+# QASM TypeScript Documentation
+
+OpenQASM, the low-level programming language for quantum circuit specification, implemented in TypeScript.
+
+QASM-TS 2.0 is an implementation of a compiler frontend for OpenQASM 2.0 and 3.0. It includes a lexer and a parser of the OpenQASM language. The source is parsed into an Intermediate Representation (IR): an Abstract Syntax Tree (AST) that captures program structure including control flow and data flow.
+
+The package is aimed at enabling implementations of verification and validation software (such as semantic and static analyzers), compilers and more. These tools may be instrumental in the formalization of hybrid quantum-classical computing.
+
+Language documentation is provided by IBM [here](https://openqasm.com).
+
+## Quick Start
+
+### Installation
+
+```bash
+npm install qasm-ts
+```
+
+### Basic Usage
+
+Parse from an OpenQASM string snippet:
+
+```typescript
+import { parseString } from "qasm-ts";
+
+const qasmCode = `
+OPENQASM 3.0;
+include "stdgates.inc";
+qubit[2] q;
+h q[0];
+cx q[0], q[1];
+`;
+
+const ast = parseString(qasmCode);
+```
+
+Parse from an OpenQASM file:
+
+```typescript
+import { parseFile } from "qasm-ts";
+
+const ast = parseFile("./my-circuit.qasm");
+
+// Specify OpenQASM version explicitly
+const ast2 = parseFile("./legacy-circuit.qasm", 2); // OpenQASM 2.0
+const ast3 = parseFile("./modern-circuit.qasm", 3); // OpenQASM 3.0
+```
+
+### Working with the AST
+
+```typescript
+// Get verbose output with class names
+const verboseAst = parseString(qasmCode, 3, true);
+
+// Get stringified JSON output
+const jsonAst = parseString(qasmCode, 3, false, true);
+
+// Both verbose and stringified
+const verboseJsonAst = parseString(qasmCode, 3, true, true);
+```
+
+## Example I/O
+
+### Input: `alignment.qasm` ([source](https://github.com/openqasm/openqasm/blob/main/examples/alignment.qasm))
+
+```
+include "stdgates.inc";
+
+stretch g;
+
+qubit[3] q;
+barrier q;
+cx q[0], q[1];
+delay[g] q[2];
+U(pi/4, 0, pi/2) q[2];
+delay[2*g] q[2];
+barrier q;
+
+```
+
+### Output: Abstract Syntax Tree
+
+```
+[
+  Include { filename: '"stdgates.inc"' },
+  ClassicalDeclaration {
+    classicalType: StretchType {},
+    identifier: Identifier { name: 'g' },
+    initializer: null,
+    isConst: false
+  },
+  QuantumDeclaration {
+    identifier: Identifier { name: 'q' },
+    size: IntegerLiteral { value: 3 }
+  },
+  QuantumBarrier { qubits: [ [Identifier] ] },
+  QuantumGateCall {
+    quantumGateName: Identifier { name: 'cx' },
+    qubits: [ [SubscriptedIdentifier], [SubscriptedIdentifier] ],
+    parameters: null,
+    modifiers: []
+  },
+  QuantumDelay {
+    duration: Identifier { name: 'g' },
+    qubits: [ [SubscriptedIdentifier] ]
+  },
+  QuantumGateCall {
+    quantumGateName: Identifier { name: 'U' },
+    qubits: [ [SubscriptedIdentifier] ],
+    parameters: Parameters { args: [Array] },
+    modifiers: []
+  },
+  QuantumDelay {
+    duration: Arithmetic { op: '*', left: [IntegerLiteral], right: [Identifier] },
+    qubits: [ [SubscriptedIdentifier] ]
+  },
+  QuantumBarrier { qubits: [ [Identifier] ] }
+]
+```
+
+## API Documentation Navigation
+
+### Core Functions
+
+Start here for the main parsing functions:
+
+- **[parseString](functions/Main_Functions.parseString.html)** - Parse OpenQASM code from a string
+- **[parseFile](functions/Main_Functions.parseFile.html)** - Parse OpenQASM code from a file
+
+### Tokenization
+
+Understand the tokenization process and available token types:
+
+- **[OpenQASM 3.0 Tokens](modules/qasm3_token.html)** - Modern OpenQASM token set
+- **[OpenQASM 2.0 Tokens](modules/qasm2_token.html)** - Legacy OpenQASM token set
+
+### Lexing
+
+Understand the Lexer:
+
+- **[OpenQASM 3.0 Lexer](modules/qasm3_lexer.html)** - Modern OpenQASM lexer
+- **[OpenQASM 2.0 Lexer](modules/qasm2_lexer.html)** - Legacy OpenQASM lexer
+
+### AST Structure
+
+Understand the abstract syntax tree nodes:
+
+- **[OpenQASM 3.0 AST Nodes](modules/qasm3_ast.html)** - Modern OpenQASM syntax tree
+- **[OpenQASM 2.0 AST Nodes](modules/qasm2_ast.html)** - Legacy OpenQASM syntax tree
+
+### Parsing
+
+Understand the Parser:
+
+- **[OpenQASM 3.0 Parser](modules/qasm3_parser.html)** - Modern OpenQASM parser
+- **[OpenQASM 2.0 Parser](modules/qasm2_parser.html)** - Legacy OpenQASM parser
+
+### Utilities and Internals
+
+- **[Error Handling](modules/Error_Handling.html)** - All error types and their usage
+- **[Version Management](modules/Version_Management.html)** - Version detection and handling
+
+Navigate using the sidebar or search functionality to find specific functions and classes.
+
+## New In Version 2.0.0
+
+- Support for the OpenQASM 3.0 spec while retaining OpenQASM 2.0 backwards compatibility.
+
+## Source Code
+
+Feel free to clone, fork, comment or contribute on [GitHub](https://github.com/comp-phys-marc/qasm-ts)!
+
+## References
+
+The original OpenQASM authors:
+
+- Andrew W. Cross, Lev S. Bishop, John A. Smolin, Jay M. Gambetta "Open Quantum Assembly Language" [arXiv:1707.03429](https://web.archive.org/web/20210121114036/https://arxiv.org/abs/1707.03429)
+- Andrew W. Cross, Ali Javadi-Abhari, Thomas Alexander, Niel de Beaudrap, Lev S. Bishop, Steven Heidel, Colm A. Ryan, Prasahnt Sivarajah, John Smolin, Jay M. Gambetta, Blake R. Johnson "OpenQASM 3: A broader and deeper quantum assembly language" [arXiv:2104.14722](https://arxiv.org/abs/2104.14722)
+
+Another strongly typed implementation from which this project took some inspiration:
+
+- [Adam Kelly's Rust QASM Parser](https://github.com/libtangle/qasm-rust)
+
+## License
+
+Copyright 2019 Marcus Edwards
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at:
+
+```http://www.apache.org/licenses/LICENSE-2.0```
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+
+## How to Cite
+
+If you are using QASM-TS for research we appreciate any citations. Please read and cite our pre-print at https://arxiv.org/abs/2412.12578.
+
+```
+@misc{kim2024enablingverificationformalizationhybrid,
+      title={Enabling the Verification and Formalization of Hybrid Quantum-Classical Computing with OpenQASM 3.0 compatible QASM-TS 2.0}, 
+      author={Sean Kim and Marcus Edwards},
+      year={2024},
+      eprint={2412.12578},
+      archivePrefix={arXiv},
+      primaryClass={cs.PL},
+      url={https://arxiv.org/abs/2412.12578}, 
+}
+```