cddl 0.2.2 → 0.3.0

package/build/parser.js

@@ -1,16 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const tokens_1 = require("./tokens");
-const constants_1 = require("./constants");
-const utils_1 = require("./utils");
-const ast_1 = require("./ast");
-const NIL_TOKEN = { Type: tokens_1.Tokens.ILLEGAL, Literal: '' };
+import fs from 'node:fs';
+import Lexer from './lexer.js';
+import { Tokens } from './tokens.js';
+import { PREDEFINED_IDENTIFIER, BOOLEAN_LITERALS } from './constants.js';
+import { parseNumberValue } from './utils.js';
+import { Type } from './ast.js';
+const NIL_TOKEN = { Type: Tokens.ILLEGAL, Literal: '' };
 const DEFAULT_OCCURRENCE = { n: 1, m: 1 }; // exactly one time
-class Parser {
-    constructor(l) {
-        this.curToken = NIL_TOKEN;
-        this.peekToken = NIL_TOKEN;
-        this.l = l;
+export default class Parser {
+    #filePath;
+    l;
+    curToken = NIL_TOKEN;
+    peekToken = NIL_TOKEN;
+    constructor(filePath) {
+        this.#filePath = filePath;
+        this.l = new Lexer(fs.readFileSync(filePath, 'utf-8'));
         this.nextToken();
         this.nextToken();
     }
@@ -26,19 +29,19 @@ class Parser {
          * groupName /=
          * groupName //=
          */
-        if (this.curToken.Type !== tokens_1.Tokens.IDENT || !(this.peekToken.Type === tokens_1.Tokens.ASSIGN || this.peekToken.Type === tokens_1.Tokens.SLASH)) {
-            throw new Error(`group identifier expected, received "${JSON.stringify(this.curToken)}"`);
+        if (this.curToken.Type !== Tokens.IDENT || !(this.peekToken.Type === Tokens.ASSIGN || this.peekToken.Type === Tokens.SLASH)) {
+            throw this.parserError(`group identifier expected, received "${JSON.stringify(this.curToken)}"`);
         }
         let isChoiceAddition = false;
         const groupName = this.curToken.Literal;
         this.nextToken(); // eat group identifier
         // @ts-ignore
-        if (this.curToken.Type === tokens_1.Tokens.SLASH) {
+        if (this.curToken.Type === Tokens.SLASH) {
             isChoiceAddition = true;
             this.nextToken(); // eat `/`
         }
         // @ts-ignore
-        if (this.curToken.Type === tokens_1.Tokens.SLASH) {
+        if (this.curToken.Type === Tokens.SLASH) {
             this.nextToken(); // eat `/`
         }
         this.nextToken(); // eat `=`
@@ -50,7 +53,10 @@ class Parser {
         const closingTokens = this.openSegment();
         /**
          * if no group segment was opened we have a variable assignment
-         * and can return immediatelly
+         * and can return immediatelly, e.g.
+         *
+         *   attire = "bow tie" / "necktie" / "Internet attire"
+         *
          */
         if (closingTokens.length === 0) {
             if (groupName) {
@@ -64,6 +70,43 @@ class Parser {
             }
             return this.parsePropertyTypes();
         }
+        /**
+         * type or group choices can be wrapped within `(` and `)`, e.g.
+         *
+         *   attireBlock = (
+         *       "bow tie" /
+         *       "necktie" /
+         *       "Internet attire"
+         *   )
+         *   attireGroup = (
+         *       attire //
+         *       attireBlock
+         *   )
+         */
+        if (closingTokens.length && this.peekToken.Type === Tokens.SLASH) {
+            const propertyType = [];
+            while (!closingTokens.includes(this.curToken.Type)) {
+                propertyType.push(...this.parsePropertyTypes());
+                if (this.curToken.Type === Tokens.RPAREN) {
+                    this.nextToken();
+                    break;
+                }
+                this.nextToken();
+                if (this.curToken.Type === Tokens.SLASH) {
+                    this.nextToken();
+                }
+            }
+            if (groupName) {
+                const variable = {
+                    Type: 'variable',
+                    Name: groupName,
+                    IsChoiceAddition: isChoiceAddition,
+                    PropertyType: propertyType
+                };
+                return variable;
+            }
+            return propertyType;
+        }
         while (!closingTokens.includes(this.curToken.Type)) {
             const propertyType = [];
             let isUnwrapped = false;
@@ -74,7 +117,7 @@ class Parser {
             /**
              * check if variable name is unwrapped
              */
-            if (this.curToken.Literal === tokens_1.Tokens.TILDE) {
+            if (this.curToken.Literal === Tokens.TILDE) {
                 isUnwrapped = true;
                 this.nextToken(); // eat ~
             }
@@ -82,13 +125,13 @@ class Parser {
             /**
              * if `,` is found we have a group reference and jump to the next line
              */
-            if (this.curToken.Type === tokens_1.Tokens.COMMA || closingTokens.includes(this.curToken.Type)) {
+            if (this.curToken.Type === Tokens.COMMA || closingTokens.includes(this.curToken.Type)) {
                 const tokenType = this.curToken.Type;
                 let parsedComments = false;
                 /**
                  * check if line has a comment
                  */
-                if (this.curToken.Type === tokens_1.Tokens.COMMA && this.peekToken.Type === tokens_1.Tokens.COMMENT) {
+                if (this.curToken.Type === Tokens.COMMA && this.peekToken.Type === Tokens.COMMENT) {
                     this.nextToken();
                     comment = this.parseComment();
                     parsedComments = true;
@@ -97,7 +140,7 @@ class Parser {
                     HasCut: hasCut,
                     Occurrence: occurrence,
                     Name: '',
-                    Type: constants_1.PREDEFINED_IDENTIFIER.includes(propertyName)
+                    Type: PREDEFINED_IDENTIFIER.includes(propertyName)
                         ? propertyName
                         : [{
                                 Type: 'group',
@@ -112,7 +155,7 @@ class Parser {
                 /**
                  * only continue if next token contains a comma
                  */
-                if (tokenType === tokens_1.Tokens.COMMA) {
+                if (tokenType === Tokens.COMMA) {
                     continue;
                 }
                 /**
@@ -125,16 +168,16 @@ class Parser {
              * - `? "optional-key" ^ => int,`
              * - `? optional-key: int,` - since the colon shortcut includes cuts
              */
-            if (this.curToken.Type === tokens_1.Tokens.CARET || this.curToken.Type === tokens_1.Tokens.COLON) {
+            if (this.curToken.Type === Tokens.CARET || this.curToken.Type === Tokens.COLON) {
                 hasCut = true;
-                if (this.curToken.Type === tokens_1.Tokens.CARET) {
+                if (this.curToken.Type === Tokens.CARET) {
                     this.nextToken(); // eat ^
                 }
             }
             /**
-             * check if we have a choice instead of an assignment
+             * check if we have a group choice instead of an assignment
              */
-            if (this.curToken.Type === tokens_1.Tokens.SLASH && this.peekToken.Type === tokens_1.Tokens.SLASH) {
+            if (this.curToken.Type === Tokens.SLASH && this.peekToken.Type === Tokens.SLASH) {
                 const prop = {
                     HasCut: hasCut,
                     Occurrence: occurrence,
@@ -167,7 +210,7 @@ class Parser {
              * else if no colon was found, throw
              */
             if (!this.isPropertyValueSeparator()) {
-                throw new Error('Expected ":" or "=>"');
+                throw this.parserError('Expected ":" or "=>"');
             }
             this.nextToken(); // eat :
             /**
@@ -187,7 +230,7 @@ class Parser {
              * advance comma
              */
             let flipIsChoice = false;
-            if (this.curToken.Type === tokens_1.Tokens.COMMA) {
+            if (this.curToken.Type === Tokens.COMMA) {
                 /**
                  * if we are in a choice, we leave it here
                  */
@@ -235,7 +278,7 @@ class Parser {
         /**
          * if last closing token is "]" we have an array
          */
-        if (closingTokens[closingTokens.length - 1] === tokens_1.Tokens.RBRACK) {
+        if (closingTokens[closingTokens.length - 1] === Tokens.RBRACK) {
             return {
                 Type: 'array',
                 Name: groupName || '',
@@ -253,10 +296,10 @@ class Parser {
         };
     }
     isPropertyValueSeparator() {
-        if (this.curToken.Type === tokens_1.Tokens.COLON) {
+        if (this.curToken.Type === Tokens.COLON) {
             return true;
         }
-        if (this.curToken.Type === tokens_1.Tokens.ASSIGN && this.peekToken.Type === tokens_1.Tokens.GT) {
+        if (this.curToken.Type === Tokens.ASSIGN && this.peekToken.Type === Tokens.GT) {
             this.nextToken(); // eat <
             return true;
         }
@@ -268,21 +311,21 @@ class Parser {
      * @returns {String[]}  closing tokens for group (either `}`, `)` or both)
      */
     openSegment() {
-        if (this.curToken.Type === tokens_1.Tokens.LBRACE) {
+        if (this.curToken.Type === Tokens.LBRACE) {
             this.nextToken();
-            if (this.peekToken.Type === tokens_1.Tokens.LPAREN) {
+            if (this.peekToken.Type === Tokens.LPAREN) {
                 this.nextToken();
-                return [tokens_1.Tokens.RPAREN, tokens_1.Tokens.RBRACE];
+                return [Tokens.RPAREN, Tokens.RBRACE];
             }
-            return [tokens_1.Tokens.RBRACE];
+            return [Tokens.RBRACE];
         }
-        else if (this.curToken.Type === tokens_1.Tokens.LPAREN) {
+        else if (this.curToken.Type === Tokens.LPAREN) {
             this.nextToken();
-            return [tokens_1.Tokens.RPAREN];
+            return [Tokens.RPAREN];
         }
-        else if (this.curToken.Type === tokens_1.Tokens.LBRACK) {
+        else if (this.curToken.Type === Tokens.LBRACK) {
             this.nextToken();
-            return [tokens_1.Tokens.RBRACK];
+            return [Tokens.RBRACK];
         }
         return [];
     }
@@ -290,12 +333,12 @@ class Parser {
         /**
          * property name without quotes
          */
-        if (this.curToken.Type === tokens_1.Tokens.IDENT || this.curToken.Type === tokens_1.Tokens.STRING) {
+        if (this.curToken.Type === Tokens.IDENT || this.curToken.Type === Tokens.STRING) {
             const name = this.curToken.Literal;
             this.nextToken();
             return name;
         }
-        throw new Error(`Expected property name, received ${this.curToken.Type}(${this.curToken.Literal}), ${this.peekToken.Type}(${this.peekToken.Literal})`);
+        throw this.parserError(`Expected property name, received ${this.curToken.Type}(${this.curToken.Literal}), ${this.peekToken.Type}(${this.peekToken.Literal})`);
     }
     parsePropertyType() {
         let type;
@@ -303,57 +346,57 @@ class Parser {
         /**
          * check if variable name is unwrapped
          */
-        if (this.curToken.Literal === tokens_1.Tokens.TILDE) {
+        if (this.curToken.Literal === Tokens.TILDE) {
             isUnwrapped = true;
             this.nextToken(); // eat ~
         }
         switch (this.curToken.Literal) {
-            case ast_1.Type.BOOL:
-            case ast_1.Type.INT:
-            case ast_1.Type.UINT:
-            case ast_1.Type.NINT:
-            case ast_1.Type.FLOAT:
-            case ast_1.Type.FLOAT16:
-            case ast_1.Type.FLOAT32:
-            case ast_1.Type.FLOAT64:
-            case ast_1.Type.BSTR:
-            case ast_1.Type.BYTES:
-            case ast_1.Type.TSTR:
-            case ast_1.Type.TEXT:
+            case Type.BOOL:
+            case Type.INT:
+            case Type.UINT:
+            case Type.NINT:
+            case Type.FLOAT:
+            case Type.FLOAT16:
+            case Type.FLOAT32:
+            case Type.FLOAT64:
+            case Type.BSTR:
+            case Type.BYTES:
+            case Type.TSTR:
+            case Type.TEXT:
                 type = this.curToken.Literal;
                 break;
             default: {
-                if (constants_1.BOOLEAN_LITERALS.includes(this.curToken.Literal)) {
+                if (BOOLEAN_LITERALS.includes(this.curToken.Literal)) {
                     type = {
                         Type: 'literal',
                         Value: this.curToken.Literal === 'true',
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Type === tokens_1.Tokens.IDENT) {
+                else if (this.curToken.Type === Tokens.IDENT) {
                     type = {
                         Type: 'group',
                         Value: this.curToken.Literal,
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Type === tokens_1.Tokens.STRING) {
+                else if (this.curToken.Type === Tokens.STRING) {
                     type = {
                         Type: 'literal',
                         Value: this.curToken.Literal,
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Type === tokens_1.Tokens.NUMBER || this.curToken.Type === tokens_1.Tokens.FLOAT) {
+                else if (this.curToken.Type === Tokens.NUMBER || this.curToken.Type === Tokens.FLOAT) {
                     type = {
                         Type: 'literal',
-                        Value: utils_1.parseNumberValue(this.curToken),
+                        Value: parseNumberValue(this.curToken),
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Type === tokens_1.Tokens.HASH) {
+                else if (this.curToken.Type === Tokens.HASH) {
                     this.nextToken();
-                    const n = utils_1.parseNumberValue(this.curToken);
+                    const n = parseNumberValue(this.curToken);
                     this.nextToken(); // eat numeric value
                     this.nextToken(); // eat (
                     const t = this.parsePropertyType();
@@ -368,27 +411,27 @@ class Parser {
                     };
                 }
                 else {
-                    throw new Error(`Invalid property type "${this.curToken.Literal}"`);
+                    throw this.parserError(`Invalid property type "${this.curToken.Literal}"`);
                 }
             }
         }
         /**
          * check if type continue as a range
          */
-        if (this.peekToken.Type === tokens_1.Tokens.DOT &&
+        if (this.peekToken.Type === Tokens.DOT &&
             this.nextToken() &&
-            this.peekToken.Type === tokens_1.Tokens.DOT) {
+            this.peekToken.Type === Tokens.DOT) {
             this.nextToken();
             let Inclusive = true;
             /**
              * check if range excludes upper bound
              */
-            if (this.peekToken.Type === tokens_1.Tokens.DOT) {
+            if (this.peekToken.Type === Tokens.DOT) {
                 Inclusive = false;
                 this.nextToken();
             }
             this.nextToken();
-            const Min = typeof type === 'string'
+            const Min = typeof type === 'string' || typeof type.Value === 'number'
                 ? type
                 : type.Value;
             type = {
@@ -414,13 +457,13 @@ class Parser {
          *   city // lala: tstr / bool // per-pickup: true,
          * )
          */
-        if (this.curToken.Type === tokens_1.Tokens.SLASH && this.peekToken.Type === tokens_1.Tokens.SLASH) {
+        if (this.curToken.Type === Tokens.SLASH && this.peekToken.Type === Tokens.SLASH) {
             return propertyTypes;
         }
         /**
          * capture more if available (e.g. `tstr / float / boolean`)
          */
-        while (this.curToken.Type === tokens_1.Tokens.SLASH) {
+        while (this.curToken.Type === Tokens.SLASH) {
             this.nextToken(); // eat `/`
             propertyTypes.push(this.parsePropertyType());
             this.nextToken();
@@ -431,7 +474,7 @@ class Parser {
              *   city // lala: tstr / bool // per-pickup: true,
              * )
              */
-            if (this.curToken.Type === tokens_1.Tokens.SLASH && this.peekToken.Type === tokens_1.Tokens.SLASH) {
+            if (this.curToken.Type === Tokens.SLASH && this.peekToken.Type === Tokens.SLASH) {
                 break;
             }
         }
@@ -453,13 +496,13 @@ class Parser {
          *  + bedroom: size,
          * ```
          */
-        if (this.curToken.Type === tokens_1.Tokens.QUEST || this.curToken.Type === tokens_1.Tokens.ASTERISK || this.curToken.Type === tokens_1.Tokens.PLUS) {
-            const n = this.curToken.Type === tokens_1.Tokens.PLUS ? 1 : 0;
+        if (this.curToken.Type === Tokens.QUEST || this.curToken.Type === Tokens.ASTERISK || this.curToken.Type === Tokens.PLUS) {
+            const n = this.curToken.Type === Tokens.PLUS ? 1 : 0;
             let m = Infinity;
             /**
              * check if there is a max definition
              */
-            if (this.peekToken.Type === tokens_1.Tokens.NUMBER) {
+            if (this.peekToken.Type === Tokens.NUMBER) {
                 m = parseInt(this.peekToken.Literal, 10);
                 this.nextToken();
             }
@@ -472,8 +515,8 @@ class Parser {
              * ```
              */
         }
-        else if (this.curToken.Type === tokens_1.Tokens.NUMBER &&
-            this.peekToken.Type === tokens_1.Tokens.ASTERISK) {
+        else if (this.curToken.Type === Tokens.NUMBER &&
+            this.peekToken.Type === Tokens.ASTERISK) {
             const n = parseInt(this.curToken.Literal, 10);
             let m = Infinity;
             this.nextToken(); // eat "n"
@@ -481,7 +524,7 @@ class Parser {
             /**
              * check if there is a max definition
              */
-            if (this.curToken.Type === tokens_1.Tokens.NUMBER) {
+            if (this.curToken.Type === Tokens.NUMBER) {
                 m = parseInt(this.curToken.Literal, 10);
                 this.nextToken();
             }
@@ -494,7 +537,7 @@ class Parser {
      */
     parseComment() {
         let comment = '';
-        if (this.curToken.Type === tokens_1.Tokens.COMMENT) {
+        if (this.curToken.Type === Tokens.COMMENT) {
             comment = this.curToken.Literal.slice(2);
             this.nextToken();
         }
@@ -502,8 +545,8 @@ class Parser {
     }
     parse() {
         const definition = [];
-        while (this.curToken.Type !== tokens_1.Tokens.EOF) {
-            if (this.curToken.Type === tokens_1.Tokens.COMMENT) {
+        while (this.curToken.Type !== Tokens.EOF) {
+            if (this.curToken.Type === Tokens.COMMENT) {
                 const comment = {
                     Type: 'comment',
                     Content: this.curToken.Literal.slice(1).trim()
@@ -519,5 +562,9 @@ class Parser {
         }
         return definition;
     }
+    parserError(message) {
+        const location = this.l.getLocation();
+        const locInfo = this.l.getLocationInfo();
+        return new Error(`${this.#filePath.replace(process.cwd(), '')}:${location.line + 1}:${location.position} - error: ${message}\n\n${locInfo}`);
+    }
 }
-exports.default = Parser;

package/build/tokens.d.ts

@@ -1,5 +1,5 @@
-export declare type TokenType = string;
-export declare type Token = {
+export type TokenType = string;
+export type Token = {
     Type: TokenType;
     Literal: string;
 };

package/build/tokens.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,oBAAY,SAAS,GAAG,MAAM,CAAA;AAE9B,oBAAY,KAAK,GAAG;IAChB,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,oBAAY,MAAM;IACd,OAAO,YAAY;IACnB,GAAG,QAAQ;IACX,EAAE,OAAO;IACT,KAAK,MAAM;IACX,UAAU,MAAM;IAChB,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,KAAK,MAAM;IACX,IAAI,MAAM;IACV,KAAK,MAAM;IAGX,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,KAAK,UAAU;IAGf,MAAM,MAAM;IACZ,IAAI,MAAM;IACV,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,QAAQ,MAAM;IAGd,KAAK,MAAM;IACX,GAAG,MAAM;IACT,KAAK,MAAM;IACX,SAAS,MAAM;IACf,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,EAAE,MAAM;IACR,EAAE,MAAM;IACR,IAAI,OAAM;CACb"}
+{"version":3,"file":"tokens.d.ts","sourceRoot":"","sources":["../src/tokens.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,SAAS,GAAG,MAAM,CAAA;AAE9B,MAAM,MAAM,KAAK,GAAG;IAChB,IAAI,EAAE,SAAS,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,oBAAY,MAAM;IACd,OAAO,YAAY;IACnB,GAAG,QAAQ;IACX,EAAE,OAAO;IACT,KAAK,MAAM;IACX,UAAU,MAAM;IAChB,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,KAAK,MAAM;IACX,IAAI,MAAM;IACV,KAAK,MAAM;IAGX,KAAK,UAAU;IACf,GAAG,QAAQ;IACX,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,MAAM,WAAW;IACjB,KAAK,UAAU;IAGf,MAAM,MAAM;IACZ,IAAI,MAAM;IACV,KAAK,MAAM;IACX,KAAK,MAAM;IACX,KAAK,MAAM;IACX,QAAQ,MAAM;IAGd,KAAK,MAAM;IACX,GAAG,MAAM;IACT,KAAK,MAAM;IACX,SAAS,MAAM;IACf,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,MAAM,MAAM;IACZ,EAAE,MAAM;IACR,EAAE,MAAM;IACR,IAAI,OAAM;CACb"}

package/build/tokens.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Tokens = void 0;
-var Tokens;
+export var Tokens;
 (function (Tokens) {
     Tokens["ILLEGAL"] = "ILLEGAL";
     Tokens["EOF"] = "EOF";
@@ -41,4 +38,4 @@ var Tokens;
     Tokens["LT"] = "<";
     Tokens["GT"] = ">";
     Tokens["QUOT"] = "\"";
-})(Tokens = exports.Tokens || (exports.Tokens = {}));
+})(Tokens || (Tokens = {}));

package/build/transform/ts.d.ts

@@ -0,0 +1,3 @@
+import type { Assignment } from '../ast';
+export declare function transform(assignments: Assignment[]): string;
+//# sourceMappingURL=ts.d.ts.map

package/build/transform/ts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts.d.ts","sourceRoot":"","sources":["../../src/transform/ts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAA6C,MAAM,QAAQ,CAAA;AAanF,wBAAgB,SAAS,CAAE,WAAW,EAAE,UAAU,EAAE,UAoBnD"}

package/build/transform/ts.js

@@ -0,0 +1,113 @@
+import camelcase from 'camelcase';
+import { parse, print, types } from 'recast';
+import typescriptParser from 'recast/parsers/typescript.js';
+// @ts-ignore
+import pkg from '../../package.json' assert { type: 'json' };
+const b = types.builders;
+const comments = [];
+const NATIVE_TYPES = {
+    number: 'number',
+    uint: 'Uint32Array',
+    bool: 'boolean',
+    str: 'string',
+    text: 'string',
+    tstr: 'string'
+};
+export function transform(assignments) {
+    let ast = parse(`// compiled with https://www.npmjs.com/package/cddl v${pkg.version}`, {
+        parser: typescriptParser,
+        sourceFileName: 'cddl2Ts.ts',
+        sourceRoot: process.cwd()
+    });
+    for (const assignment of assignments) {
+        const statement = parseAssignment(ast, assignment);
+        if (!statement) {
+            continue;
+        }
+        ast.program.body.push(statement);
+    }
+    ast.program.comments = comments.map((c) => b.commentLine(c, false, false));
+    return print(ast).code;
+}
+function parseAssignment(ast, assignment) {
+    if (assignment.Type === 'comment') {
+        comments.push(assignment.Content);
+        return;
+    }
+    if (assignment.Type === 'variable') {
+        const propType = Array.isArray(assignment.PropertyType)
+            ? assignment.PropertyType
+            : [assignment.PropertyType];
+        const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
+        let typeParameters;
+        // @ts-expect-error e.g. "js-int = -9007199254740991..9007199254740991"
+        if (propType.length === 1 && propType[0].Type === 'range') {
+            typeParameters = b.tsNumberKeyword();
+        }
+        else {
+            typeParameters = b.tsUnionType(propType.map(parsePropertyType));
+        }
+        const expr = b.tsTypeAliasDeclaration(id, typeParameters);
+        expr.comments = comments.map((c) => b.commentLine(c, true));
+        return expr;
+    }
+    if (assignment.Type === 'group') {
+        const id = b.identifier(camelcase(assignment.Name, { pascalCase: true }));
+        const objectType = parseObjectType(assignment.Properties);
+        const expr = b.interfaceDeclaration(id, objectType, []);
+        return expr;
+    }
+}
+function parsePropertyType(propType) {
+    if (typeof propType === 'string') {
+        return b.tsStringKeyword();
+    }
+    if (propType.Type === 'group') {
+        return b.tsTypeReference(b.identifier(propType.Value.toString()));
+    }
+    if (propType.Type === 'literal') {
+        return b.tsLiteralType(b.stringLiteral(propType.Value.toString()));
+    }
+    throw new Error(`Couldn't parse property type ${JSON.stringify(propType, null, 4)}`);
+}
+function parseObjectType(props) {
+    const propItems = [];
+    for (const prop of props) {
+        /**
+         * ToDo(Christian): support Extensible
+         */
+        if (prop.Name === '') {
+            propItems[propItems.length - 1].comments = [b.commentLine(`Missing: ${JSON.stringify(prop)}`)];
+            continue;
+        }
+        const id = b.identifier(camelcase(prop.Name));
+        const cddlType = Array.isArray(prop.Type) ? prop.Type : [prop.Type];
+        const typeParameters = b.unionTypeAnnotation(cddlType.map((t) => {
+            if (typeof t === 'string') {
+                if (!NATIVE_TYPES[t]) {
+                    throw new Error(`Unknown native type: "${t}`);
+                }
+                return b.typeParameter(NATIVE_TYPES[t]);
+            }
+            else if (t.Value === 'null') {
+                return b.nullTypeAnnotation();
+            }
+            else if (t.Type === 'group') {
+                const value = t.Value;
+                return b.typeParameter(
+                /**
+                 * transform native CDDL types into TypeScript types
+                 */
+                NATIVE_TYPES[value] ? value : camelcase(value.toString(), { pascalCase: true }));
+            }
+            else if (t.Type === 'literal' && typeof t.Value === 'string') {
+                return b.stringLiteralTypeAnnotation(t.Value, t.Value);
+            }
+            throw new Error(`Couldn't parse property ${JSON.stringify(t)}`);
+        }));
+        const isOptional = prop.Occurrence.n === 0;
+        propItems.push(b.objectTypeProperty(id, typeParameters, isOptional));
+    }
+    const obj = b.objectTypeAnnotation(propItems);
+    return obj;
+}

package/build/types.d.ts

@@ -0,0 +1,5 @@
+import { ParseTargets } from './constants.js';
+export interface ParseOptions {
+    target: ParseTargets;
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAE7C,MAAM,WAAW,YAAY;IACzB,MAAM,EAAE,YAAY,CAAA;CACvB"}

package/build/types.js

@@ -0,0 +1 @@
+export {};

package/build/utils.d.ts

@@ -1,4 +1,4 @@
-import { Token } from './tokens';
+import { Token } from './tokens.js';
 export declare function isLetter(ch: string): boolean;
 export declare function isAlphabeticCharacter(ch: string): boolean;
 export declare function isDigit(ch: string): boolean;

package/build/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,MAAM,UAAU,CAAA;AAExC,wBAAgB,QAAQ,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,qBAAqB,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,yBAAyB,CAAE,EAAE,EAAE,MAAM,WAMpD;AAED,wBAAgB,gBAAgB,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAa/D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,KAAK,EAAE,MAAM,aAAa,CAAA;AAE3C,wBAAgB,QAAQ,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE7C;AAED,wBAAgB,qBAAqB,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE1D;AAED,wBAAgB,OAAO,CAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAE5C;AAED,wBAAgB,yBAAyB,CAAE,EAAE,EAAE,MAAM,WAOpD;AAED,wBAAgB,gBAAgB,CAAE,KAAK,EAAE,KAAK,GAAG,MAAM,GAAG,MAAM,CAa/D"}