qasm-ts 2.1.1 → 2.1.3

package/dist/qasm3/token.js

@@ -1,425 +0,0 @@
-"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

@@ -1,57 +0,0 @@
-"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;