cddl 0.14.10 → 0.16.0

package/build/index.d.ts

@@ -7,4 +7,5 @@ declare const _default: {
 export default _default;
 export { Lexer, Parser };
 export * from './ast.js';
+export * from './utils.js';
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,wBAAgB,KAAK,CAAE,QAAQ,EAAE,MAAM,mCAGtC;;;;AAED,wBAAwB;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AACxB,cAAc,UAAU,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,YAAY,CAAA;AAC9B,OAAO,MAAM,MAAM,aAAa,CAAA;AAEhC,wBAAgB,KAAK,CAAE,QAAQ,EAAE,MAAM,mCAGtC;;;;AAED,wBAAwB;AACxB,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AACxB,cAAc,UAAU,CAAA;AACxB,cAAc,YAAY,CAAA"}

package/build/index.js

@@ -7,3 +7,4 @@ export function parse(filePath) {
 export default { parse };
 export { Lexer, Parser };
 export * from './ast.js';
+export * from './utils.js';

package/build/parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,OAAO,EAAE,KAAK,EAAU,MAAM,aAAa,CAAC;AAG5C,OAAO,EAE2C,UAAU,EAE3D,MAAM,UAAU,CAAA;AAoBjB,MAAM,CAAC,OAAO,OAAO,MAAM;;IAEvB,CAAC,EAAE,KAAK,CAAC;IAET,QAAQ,EAAE,KAAK,CAAa;IAC5B,SAAS,EAAE,KAAK,CAAa;IAC7B,cAAc,EAAE,KAAK,CAAa;gBAErB,QAAQ,EAAE,MAAM;IAS7B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,gBAAgB;IA2CxB,OAAO,CAAC,oBAAoB;IAue5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqKzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IAuD1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB,KAAK;IAaL,OAAO,CAAC,WAAW;CAKtB"}
+{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,MAAM,YAAY,CAAA;AAE9B,OAAO,EAAE,KAAK,EAAU,MAAM,aAAa,CAAC;AAG5C,OAAO,EAE2C,UAAU,EAE3D,MAAM,UAAU,CAAA;AAoBjB,MAAM,CAAC,OAAO,OAAO,MAAM;;IAEvB,CAAC,EAAE,KAAK,CAAC;IAET,QAAQ,EAAE,KAAK,CAAa;IAC5B,SAAS,EAAE,KAAK,CAAa;IAC7B,cAAc,EAAE,KAAK,CAAa;gBAErB,QAAQ,EAAE,MAAM;IAS7B,OAAO,CAAC,SAAS;IAOjB,OAAO,CAAC,gBAAgB;IA8CxB,OAAO,CAAC,oBAAoB;IAue5B,OAAO,CAAC,wBAAwB;IAahC;;;;OAIG;IACH,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,iBAAiB;IAazB,OAAO,CAAC,iBAAiB;IAqKzB,OAAO,CAAC,aAAa;IAgBrB,OAAO,CAAC,UAAU;IAIlB,OAAO,CAAC,kBAAkB;IA8E1B,OAAO,CAAC,gBAAgB;IA4DxB;;OAEG;IACH,OAAO,CAAC,YAAY;IAcpB,KAAK;IAaL,OAAO,CAAC,WAAW;CAKtB"}

package/build/parser.js

@@ -43,7 +43,10 @@ export default class Parser {
     parseAssignments() {
         const comments = [];
         while (this.curToken.Type === Tokens.COMMENT) {
-            comments.push(this.parseComment());
+            const comment = this.parseComment();
+            if (comment) {
+                comments.push(comment);
+            }
         }
         /**
          * expect group identifier, e.g.
@@ -588,7 +591,7 @@ export default class Parser {
                         Unwrapped: isUnwrapped
                     };
                 }
-                else if (this.curToken.Literal === Tokens.LBRACE) {
+                else if (this.curToken.Literal === Tokens.LBRACE || this.curToken.Literal === Tokens.LBRACK) {
                     const val = this.parseAssignmentValue();
                     if (Array.isArray(val)) {
                         throw new Error('Unexpected array in property type parsing');
@@ -739,6 +742,21 @@ export default class Parser {
             this.nextToken(); // eat Property if not already consumed (e.g. by Group parsing)
         }
         propertyTypes.push(prop);
+        /**
+         * ignore comments between type choice members, e.g.
+         * ```
+         * Foo = int ; comment
+         *     / text
+         * ```
+         * or
+         * ```
+         * Foo = int / ; comment
+         *     text
+         * ```
+         */
+        while (this.curToken.Type === Tokens.COMMENT && this.peekToken.Type === Tokens.SLASH) {
+            this.parseComment();
+        }
         /**
          * ensure we don't go into the next choice, e.g.:
          * ```
@@ -754,6 +772,9 @@ export default class Parser {
          */
         while (this.curToken.Type === Tokens.SLASH) {
             this.nextToken(); // eat `/`
+            while ([Tokens.COMMENT].includes(this.curToken.Type)) {
+                this.parseComment();
+            }
             propertyTypes.push(this.parsePropertyType());
             if (!this.isOperator() && this.curToken.Type !== Tokens.SLASH) {
                 /**
@@ -762,6 +783,9 @@ export default class Parser {
                  */
                 this.nextToken();
             }
+            while ([Tokens.COMMENT].includes(this.curToken.Type) && this.peekToken.Type === Tokens.SLASH) {
+                this.parseComment();
+            }
             /**
              * ensure we don't go into the next choice, e.g.:
              * ```

package/build/utils.d.ts

@@ -1,7 +1,26 @@
+import type { Assignment, Array as CDDLArray, Group, NativeTypeWithOperator, Property, PropertyReference, Variable } from './ast.js';
 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;
 export declare function hasSpecialNumberCharacter(ch: number): boolean;
 export declare function parseNumberValue(token: Token): string | number;
+export declare function pascalCase(name: string): string;
+export declare function isVariable(assignment: Assignment): assignment is Variable;
+export declare function isGroup(t: any): t is Group;
+export declare function isCDDLArray(t: any): t is CDDLArray;
+export declare function isProperty(t: any): t is Property;
+export declare function isUnNamedProperty(t: any): t is Property & {
+    Name: '';
+};
+export declare function isNamedGroupReference(t: any): t is PropertyReference & {
+    Value: string;
+};
+export declare function isPropertyReference(t: any): t is PropertyReference;
+export declare function isNativeTypeWithOperator(t: any): t is NativeTypeWithOperator;
+export declare function isRange(t: any): boolean;
+export declare function isLiteralWithValue(t: any): t is {
+    Type: 'literal';
+    Value: unknown;
+};
 //# sourceMappingURL=utils.d.ts.map

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,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"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACR,UAAU,EACV,KAAK,IAAI,SAAS,EAClB,KAAK,EACL,sBAAsB,EACtB,QAAQ,EACR,iBAAiB,EACjB,QAAQ,EACX,MAAM,UAAU,CAAA;AAEjB,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;AAED,wBAAgB,UAAU,CAAE,IAAI,EAAE,MAAM,UAEvC;AAED,wBAAgB,UAAU,CAAE,UAAU,EAAE,UAAU,GAAG,UAAU,IAAI,QAAQ,CAE1E;AAED,wBAAgB,OAAO,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,KAAK,CAE3C;AAED,wBAAgB,WAAW,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,SAAS,CAEnD;AAED,wBAAgB,UAAU,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,CAEjD;AAED,wBAAgB,iBAAiB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,QAAQ,GAAG;IAAE,IAAI,EAAE,EAAE,CAAA;CAAE,CAEvE;AAED,wBAAgB,qBAAqB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,CAEzF;AAED,wBAAgB,mBAAmB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,iBAAiB,CAEnE;AAED,wBAAgB,wBAAwB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI,sBAAsB,CAE7E;AAED,wBAAgB,OAAO,CAAE,CAAC,EAAE,GAAG,GAAG,OAAO,CAExC;AAED,wBAAgB,kBAAkB,CAAE,CAAC,EAAE,GAAG,GAAG,CAAC,IAAI;IAC9C,IAAI,EAAE,SAAS,CAAA;IACf,KAAK,EAAE,OAAO,CAAA;CACjB,CAEA"}

package/build/utils.js

@@ -1,3 +1,4 @@
+import camelcase from 'camelcase';
 import { Tokens } from './tokens.js';
 export function isLetter(ch) {
     return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z';
@@ -24,3 +25,36 @@ export function parseNumberValue(token) {
     }
     return parseInt(token.Literal, 10);
 }
+export function pascalCase(name) {
+    return camelcase(name, { pascalCase: true });
+}
+export function isVariable(assignment) {
+    return assignment.Type === 'variable';
+}
+export function isGroup(t) {
+    return t && t.Type === 'group';
+}
+export function isCDDLArray(t) {
+    return t && t.Type === 'array';
+}
+export function isProperty(t) {
+    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean';
+}
+export function isUnNamedProperty(t) {
+    return isProperty(t) && t.Name === '';
+}
+export function isNamedGroupReference(t) {
+    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string';
+}
+export function isPropertyReference(t) {
+    return t && typeof t === 'object' && 'Value' in t;
+}
+export function isNativeTypeWithOperator(t) {
+    return t && typeof t.Type === 'object' && 'Operator' in t;
+}
+export function isRange(t) {
+    return t && typeof t.Type === 'object' && t.Type.Type === 'range';
+}
+export function isLiteralWithValue(t) {
+    return t && t.Type === 'literal' && 'Value' in t;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cddl",
-  "version": "0.14.10",
+  "version": "0.16.0",
   "description": "Concise data definition language (RFC 8610) implementation and JSON validator in Node.js",
   "author": "Christian Bromann <mail@bromann.dev>",
   "license": "MIT",
@@ -26,6 +26,7 @@
     "@types/yargs": "^17.0.35"
   },
   "dependencies": {
+    "camelcase": "^9.0.0",
     "yargs": "^18.0.0"
   },
   "scripts": {

package/src/index.ts

@@ -9,3 +9,4 @@ export function parse (filePath: string) {
 export default { parse }
 export { Lexer, Parser }
 export * from './ast.js'
+export * from './utils.js'

package/src/parser.ts

@@ -56,7 +56,10 @@ export default class Parser {
     private parseAssignments (): Assignment {
         const comments: Comment[] = []
         while (this.curToken.Type === Tokens.COMMENT) {
-            comments.push(this.parseComment()!)
+            const comment = this.parseComment()
+            if (comment) {
+                comments.push(comment)
+            }
         }
 
         /**
@@ -667,12 +670,12 @@ export default class Parser {
                         Value: this.curToken.Literal === 'true',
                         Unwrapped: isUnwrapped
                     }
-                } else if (this.curToken.Literal === Tokens.LBRACE) {
-                   const val = this.parseAssignmentValue();
-                   if (Array.isArray(val)) {
-                     throw new Error('Unexpected array in property type parsing');
-                   }
-                   type = val
+                } else if (this.curToken.Literal === Tokens.LBRACE || this.curToken.Literal === Tokens.LBRACK) {
+                    const val = this.parseAssignmentValue()
+                    if (Array.isArray(val)) {
+                        throw new Error('Unexpected array in property type parsing')
+                    }
+                    type = val
                 } else if (this.curToken.Type === Tokens.IDENT) {
                     type = {
                         Type: 'group' as PropertyReferenceType,
@@ -829,6 +832,22 @@ export default class Parser {
 
         propertyTypes.push(prop)
 
+        /**
+         * ignore comments between type choice members, e.g.
+         * ```
+         * Foo = int ; comment
+         *     / text
+         * ```
+         * or
+         * ```
+         * Foo = int / ; comment
+         *     text
+         * ```
+         */
+        while (this.curToken.Type === Tokens.COMMENT && this.peekToken.Type === Tokens.SLASH) {
+            this.parseComment()
+        }
+
         /**
          * ensure we don't go into the next choice, e.g.:
          * ```
@@ -845,6 +864,9 @@ export default class Parser {
          */
         while (this.curToken.Type === Tokens.SLASH) {
             this.nextToken() // eat `/`
+            while ([Tokens.COMMENT].includes(this.curToken.Type)) {
+                this.parseComment()
+            }
             propertyTypes.push(this.parsePropertyType())
             if (!this.isOperator() && this.curToken.Type !== Tokens.SLASH) {
                 /**
@@ -854,6 +876,10 @@ export default class Parser {
                 this.nextToken()
             }
 
+            while ([Tokens.COMMENT].includes(this.curToken.Type) && this.peekToken.Type === Tokens.SLASH) {
+                this.parseComment()
+            }
+
             /**
              * ensure we don't go into the next choice, e.g.:
              * ```

package/src/utils.ts

@@ -1,3 +1,15 @@
+import camelcase from 'camelcase'
+
+import type {
+    Assignment,
+    Array as CDDLArray,
+    Group,
+    NativeTypeWithOperator,
+    Property,
+    PropertyReference,
+    Variable
+} from './ast.js'
+
 import { Tokens, Token } from './tokens.js'
 
 export function isLetter (ch: string): boolean {
@@ -35,3 +47,50 @@ export function parseNumberValue (token: Token): string | number {
 
     return parseInt(token.Literal, 10)
 }
+
+export function pascalCase (name: string) {
+    return camelcase(name, { pascalCase: true })
+}
+
+export function isVariable (assignment: Assignment): assignment is Variable {
+    return assignment.Type === 'variable'
+}
+
+export function isGroup (t: any): t is Group {
+    return t && t.Type === 'group'
+}
+
+export function isCDDLArray (t: any): t is CDDLArray {
+    return t && t.Type === 'array'
+}
+
+export function isProperty (t: any): t is Property {
+    return t && typeof t.Name === 'string' && typeof t.HasCut === 'boolean'
+}
+
+export function isUnNamedProperty (t: any): t is Property & { Name: '' } {
+    return isProperty(t) && t.Name === ''
+}
+
+export function isNamedGroupReference (t: any): t is PropertyReference & { Value: string } {
+    return isGroup(t) && isPropertyReference(t) && typeof t.Value === 'string'
+}
+
+export function isPropertyReference (t: any): t is PropertyReference {
+    return t && typeof t === 'object' && 'Value' in t
+}
+
+export function isNativeTypeWithOperator (t: any): t is NativeTypeWithOperator {
+    return t && typeof t.Type === 'object' && 'Operator' in t
+}
+
+export function isRange (t: any): boolean {
+    return t && typeof t.Type === 'object' && (t.Type as any).Type === 'range'
+}
+
+export function isLiteralWithValue (t: any): t is {
+    Type: 'literal'
+    Value: unknown
+} {
+    return t && t.Type === 'literal' && 'Value' in t
+}

package/tests/__snapshots__/group-choices.test.ts.snap

@@ -262,6 +262,131 @@ exports[`Group Choice Parsing > Type Choice (/) > should correctly handle slash
 ]
 `;
 
+exports[`Group Choice Parsing > Type Choice (/) > should parse inline array alternatives inside map properties 1`] = `
+[
+  {
+    "Comments": [],
+    "IsChoiceAddition": false,
+    "Name": "StorePutParams",
+    "Properties": [
+      {
+        "Comments": [],
+        "HasCut": true,
+        "Name": "storeNamespace",
+        "Occurrence": {
+          "m": 1,
+          "n": 1,
+        },
+        "Type": [
+          {
+            "Comments": [],
+            "Name": "",
+            "Type": "array",
+            "Values": [
+              {
+                "Comments": [],
+                "HasCut": false,
+                "Name": "",
+                "Occurrence": {
+                  "m": Infinity,
+                  "n": 0,
+                },
+                "Type": "text",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        "Comments": [],
+        "HasCut": true,
+        "Name": "key",
+        "Occurrence": {
+          "m": 1,
+          "n": 1,
+        },
+        "Type": [
+          "text",
+        ],
+      },
+      {
+        "Comments": [],
+        "HasCut": true,
+        "Name": "value",
+        "Occurrence": {
+          "m": 1,
+          "n": 1,
+        },
+        "Type": [
+          {
+            "Comments": [],
+            "IsChoiceAddition": false,
+            "Name": "",
+            "Properties": [
+              {
+                "Comments": [],
+                "HasCut": false,
+                "Name": "text",
+                "Occurrence": {
+                  "m": Infinity,
+                  "n": 0,
+                },
+                "Type": [
+                  "any",
+                ],
+              },
+            ],
+            "Type": "group",
+          },
+        ],
+      },
+      {
+        "Comments": [],
+        "HasCut": true,
+        "Name": "index",
+        "Occurrence": {
+          "m": Infinity,
+          "n": 0,
+        },
+        "Type": [
+          "bool",
+          {
+            "Comments": [],
+            "Name": "",
+            "Type": "array",
+            "Values": [
+              {
+                "Comments": [],
+                "HasCut": false,
+                "Name": "",
+                "Occurrence": {
+                  "m": Infinity,
+                  "n": 0,
+                },
+                "Type": "text",
+              },
+            ],
+          },
+        ],
+      },
+      {
+        "Comments": [],
+        "HasCut": true,
+        "Name": "ttl",
+        "Occurrence": {
+          "m": Infinity,
+          "n": 0,
+        },
+        "Type": [
+          "uint",
+        ],
+      },
+    ],
+    "Type": "group",
+  },
+]
+`;
+
 exports[`Group Choice Parsing > Type Choice (/) > should parse type choice inside group 1`] = `
 [
   {

package/tests/group-choices.test.ts

@@ -70,6 +70,21 @@ describe('Group Choice Parsing', () => {
             expect(ast).toMatchSnapshot()
         })
 
+        it('should treat comments around type choice separators the same', () => {
+            const slashAfterComment = `
+                FlowStrategy = "drop-oldest"            ; Discard oldest when buffer is full
+                             / "pause-producer"          ; Apply backpressure to slow production
+                             / "sample"                  ; Deliver every Nth event under pressure
+            `
+            const slashBeforeComment = `
+                FlowStrategy = "drop-oldest" /           ; Discard oldest when buffer is full
+                               "pause-producer" /        ; Apply backpressure to slow production
+                               "sample"                  ; Deliver every Nth event under pressure
+            `
+
+            expect(parse(slashAfterComment)).toEqual(parse(slashBeforeComment))
+        })
+
         // This tests the change: closingTokens.includes(Tokens.RPAREN) && this.peekToken.Type === Tokens.SLASH
         it('should correctly handle slash in mixed context', () => {
             const cddl = `
@@ -78,6 +93,20 @@ describe('Group Choice Parsing', () => {
             const ast = parse(cddl)
             expect(ast).toMatchSnapshot()
         })
+
+        it('should parse inline array alternatives inside map properties', () => {
+            const cddl = `
+                StorePutParams = {
+                    storeNamespace: [* text],
+                    key: text,
+                    value: {* text => any},
+                    ? index: bool / [* text],
+                    ? ttl: uint,
+                }
+            `
+            const ast = parse(cddl)
+            expect(ast).toMatchSnapshot()
+        })
     })
 
     describe('Blocks with Braces', () => {

package/tests/parser.test.ts

@@ -41,4 +41,23 @@ describe('parser', () => {
         expect(() => p.parse()).toThrow('group identifier expected')
         vi.restoreAllMocks()
     })
+
+    it('skips blank comment lines in assignment comments', () => {
+        vi.spyOn(fs, 'readFileSync').mockReturnValue('; heading\n;\nfoo = int\n')
+        const p = new Parser('foo.cddl')
+
+        expect(p.parse()).toEqual([{
+            Type: 'variable',
+            Name: 'foo',
+            IsChoiceAddition: false,
+            PropertyType: ['int'],
+            Comments: [{
+                Type: 'comment',
+                Content: 'heading',
+                Leading: false
+            }]
+        }])
+
+        vi.restoreAllMocks()
+    })
 })

package/tests/utils.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect } from 'vitest'
+
+import type {
+    Array as CDDLArray,
+    Assignment,
+    Comment,
+    Group,
+    NativeTypeWithOperator,
+    Property,
+    PropertyReference,
+    Variable
+} from '../src/ast.js'
+import { Tokens, type Token } from '../src/tokens.js'
+import {
+    hasSpecialNumberCharacter,
+    isAlphabeticCharacter,
+    isCDDLArray,
+    isDigit,
+    isGroup,
+    isLetter,
+    isLiteralWithValue,
+    isNamedGroupReference,
+    isNativeTypeWithOperator,
+    isProperty,
+    isPropertyReference,
+    isRange,
+    isUnNamedProperty,
+    isVariable,
+    parseNumberValue,
+    pascalCase
+} from '../src/utils.js'
+
+const comments: Comment[] = []
+
+function createVariable (): Variable {
+    return {
+        Type: 'variable',
+        Name: 'my-variable',
+        IsChoiceAddition: false,
+        PropertyType: 'tstr',
+        Comments: comments
+    }
+}
+
+function createGroup (): Group {
+    return {
+        Type: 'group',
+        Name: 'my-group',
+        IsChoiceAddition: false,
+        Properties: [],
+        Comments: comments
+    }
+}
+
+function createArray (): CDDLArray {
+    return {
+        Type: 'array',
+        Name: 'my-array',
+        Values: [],
+        Comments: comments
+    }
+}
+
+function createProperty (overrides: Partial<Property> = {}): Property {
+    return {
+        HasCut: false,
+        Occurrence: { n: 1, m: 1 },
+        Name: 'foo',
+        Type: 'tstr',
+        Comments: comments,
+        ...overrides
+    }
+}
+
+describe('utils', () => {
+    describe('character helpers', () => {
+        it('should detect letters and alphabetic characters', () => {
+            expect(isLetter('a')).toBe(true)
+            expect(isLetter('Z')).toBe(true)
+            expect(isLetter('1')).toBe(false)
+
+            expect(isAlphabeticCharacter('a')).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.ATSIGN)).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.UNDERSCORE)).toBe(true)
+            expect(isAlphabeticCharacter(Tokens.DOLLAR)).toBe(true)
+            expect(isAlphabeticCharacter('-')).toBe(false)
+        })
+
+        it('should detect digits and special number characters', () => {
+            expect(isDigit('1')).toBe(true)
+            expect(isDigit('0')).toBe(true)
+            expect(isDigit('a')).toBe(false)
+            expect(isDigit(Tokens.NL)).toBe(false)
+            expect(isDigit(Tokens.SPACE)).toBe(false)
+
+            expect(hasSpecialNumberCharacter(Tokens.MINUS.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter(Tokens.DOT.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('x'.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('b'.charCodeAt(0))).toBe(true)
+            expect(hasSpecialNumberCharacter('1'.charCodeAt(0))).toBe(false)
+        })
+    })
+
+    describe('number parsing helpers', () => {
+        it('should parse floats, integers and prefixed numbers', () => {
+            const floatToken: Token = { Type: Tokens.FLOAT, Literal: '12.5' }
+            const intToken: Token = { Type: Tokens.INT, Literal: '42' }
+            const hexToken: Token = { Type: Tokens.INT, Literal: '0x10' }
+            const binaryToken: Token = { Type: Tokens.INT, Literal: '0b10' }
+
+            expect(parseNumberValue(floatToken)).toBe(12.5)
+            expect(parseNumberValue(intToken)).toBe(42)
+            expect(parseNumberValue(hexToken)).toBe('0x10')
+            expect(parseNumberValue(binaryToken)).toBe('0b10')
+        })
+    })
+
+    describe('name helpers', () => {
+        it('should convert names to pascal case', () => {
+            expect(pascalCase('my-example_name')).toBe('MyExampleName')
+        })
+    })
+
+    describe('assignment guards', () => {
+        it('should detect variables, groups and arrays', () => {
+            const variable: Assignment = createVariable()
+            const group: Assignment = createGroup()
+            const array: Assignment = createArray()
+
+            expect(isVariable(variable)).toBe(true)
+            expect(isVariable(group)).toBe(false)
+
+            expect(isGroup(group)).toBe(true)
+            expect(isGroup(variable)).toBe(false)
+
+            expect(isCDDLArray(array)).toBe(true)
+            expect(isCDDLArray(group)).toBe(false)
+        })
+    })
+
+    describe('property guards', () => {
+        it('should detect named and unnamed properties', () => {
+            const property = createProperty()
+            const unnamedProperty = createProperty({ Name: '' })
+
+            expect(isProperty(property)).toBe(true)
+            expect(isProperty({ Name: 'foo' })).toBe(false)
+
+            expect(isUnNamedProperty(unnamedProperty)).toBe(true)
+            expect(isUnNamedProperty(property)).toBe(false)
+        })
+    })
+
+    describe('reference and operator guards', () => {
+        it('should detect property references and named group references', () => {
+            const groupReference: PropertyReference = {
+                Type: 'group',
+                Value: 'my-group',
+                Unwrapped: false
+            }
+            const numericGroupReference: PropertyReference = {
+                Type: 'group',
+                Value: 123,
+                Unwrapped: false
+            }
+
+            expect(isPropertyReference(groupReference)).toBe(true)
+            expect(isPropertyReference({ Type: 'group' })).toBe(false)
+
+            expect(isNamedGroupReference(groupReference)).toBe(true)
+            expect(isNamedGroupReference(numericGroupReference)).toBe(false)
+        })
+
+        it('should detect native types with operators and ranges', () => {
+            const nativeTypeWithOperator: NativeTypeWithOperator = {
+                Type: {
+                    Type: 'group',
+                    Value: 'my-group',
+                    Unwrapped: false
+                },
+                Operator: {
+                    Type: 'default',
+                    Value: 'tstr'
+                }
+            }
+            const rangeReference: PropertyReference = {
+                Type: 'range',
+                Value: {
+                    Min: 0,
+                    Max: 10,
+                    Inclusive: true
+                },
+                Unwrapped: false
+            }
+
+            expect(isNativeTypeWithOperator(nativeTypeWithOperator)).toBe(true)
+            expect(isNativeTypeWithOperator({ Type: 'tstr' })).toBe(false)
+
+            expect(isRange({ Type: rangeReference })).toBe(true)
+            expect(isRange({ Type: 'range' })).toBe(false)
+        })
+    })
+
+    describe('literal guards', () => {
+        it('should detect literals with values', () => {
+            expect(isLiteralWithValue({ Type: 'literal', Value: 'foo' })).toBe(true)
+            expect(isLiteralWithValue({ Type: 'literal' })).toBe(false)
+            expect(isLiteralWithValue({ Type: 'group', Value: 'foo' })).toBe(false)
+        })
+    })
+})