fix: align identifier parsing with CSS standards and browser behaviour

Author: mdevils

src/parser.ts

@@ -269,6 +269,17 @@ export function createParser(
             return null;
         }
         let result = '';
+        while (is('-')) {
+            result += chr;
+            next();
+        }
+        if (strict && result.length >= 2) {
+            // Checking this only for strict mode since browsers work fine with these identifiers.
+            fail('Identifiers cannot start with two hyphens with strict mode on.');
+        }
+        if (digitsChars[chr]) {
+            fail('Identifiers cannot start with hyphens followed by digits.');
+        }
         while (pos < l) {
             if (isIdent(chr)) {
                 result += readAndNext();
@@ -281,7 +292,7 @@ export function createParser(
                     result += readAndNext();
                 }
             } else {
-                return result;
+                break;
             }
         }
         return result;

src/utils.ts

@@ -1,9 +1,16 @@
 export function isIdentStart(c: string) {
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '-' || c === '_' || c === '\\';
+    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c === '-' || c === '_' || c === '\\' || c >= '\u00a0';
 }
 
 export function isIdent(c: string) {
-    return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c === '-' || c === '_';
+    return (
+        (c >= 'a' && c <= 'z') ||
+        (c >= 'A' && c <= 'Z') ||
+        (c >= '0' && c <= '9') ||
+        c === '-' ||
+        c === '_' ||
+        c >= '\u00a0'
+    );
 }
 
 export function isHex(c: string) {

test/parser.test.ts

@@ -5,6 +5,61 @@ describe('parse()', () => {
         syntax: 'progressive'
     });
 
+    describe('Identifiers', () => {
+        it('should parse a regular valid identifier', () => {
+            expect(parse('#id')).toEqual(
+                ast.selector({
+                    rules: [
+                        ast.rule({
+                            items: [ast.id({name: 'id'})]
+                        })
+                    ]
+                })
+            );
+        });
+        it('should parse an identifier starting with a hyphen', () => {
+            expect(parse('#-id')).toEqual(
+                ast.selector({
+                    rules: [
+                        ast.rule({
+                            items: [ast.id({name: '-id'})]
+                        })
+                    ]
+                })
+            );
+        });
+        it('should fail on an identifier starting with multiple hyphens', () => {
+            expect(() => parse('#--id')).toThrow('Identifiers cannot start with two hyphens with strict mode on.');
+        });
+        it('should parse an identifier starting with multiple hyphens in case of strict: false', () => {
+            expect(createParser({strict: false})('#--id')).toEqual(
+                ast.selector({
+                    rules: [
+                        ast.rule({
+                            items: [ast.id({name: '--id'})]
+                        })
+                    ]
+                })
+            );
+        });
+        it('should fail on an identifier starting with a hyphen and followed with a digit', () => {
+            expect(() => parse('#-1')).toThrow('Identifiers cannot start with hyphens followed by digits.');
+            expect(() => createParser({strict: false})('#--1')).toThrow(
+                'Identifiers cannot start with hyphens followed by digits.'
+            );
+        });
+        it('should parse an identifier consisting unicode characters', () => {
+            expect(parse('#ÈÈ')).toEqual(
+                ast.selector({
+                    rules: [
+                        ast.rule({
+                            items: [ast.id({name: 'ÈÈ'})]
+                        })
+                    ]
+                })
+            );
+        });
+    });
     describe('Tag Names', () => {
         it('should parse a tag name', () => {
             expect(parse('div')).toEqual(