diff --git a/src/languageFacts/colors.ts b/src/languageFacts/colors.ts
index 3086c8b7..ddb96838 100644
--- a/src/languageFacts/colors.ts
+++ b/src/languageFacts/colors.ts
@@ -132,9 +132,34 @@ export const colorFunctions = [
 		insertText: 'color-mix(in ${1|hsl,hwb,lch,oklch|} ${2|shorter hue,longer hue,increasing hue,decreasing hue|}, ${3:color} ${4:percentage}, ${5:color} ${6:percentage})',
 		desc: l10n.t('Mix two colors together in a polar color space.')
 	},
+	{
+		label: 'lab',
+		func: 'lab($lightness $channel_a $channel_b $alpha)',
+		insertText: 'lab(${1:lightness} ${2:a} ${3:b} ${4:alpha})',
+		desc: l10n.t('css.builtin.lab', 'Creates a Color from Lightness, Channel a, Channel b and alpha values.')
+	},
+	{
+		label: 'lab relative',
+		func: 'lab(from $color $lightness $channel_a $channel_b $alpha)',
+		insertText: 'lab(from ${1:color} ${2:lightness} ${3:channel_a} ${4:channel_b} ${5:alpha})',
+		desc: l10n.t('css.builtin.lab', 'Creates a Color from Lightness, Channel a, Channel b and alpha values of another Color.')
+	},
+	{
+		label: 'lch',
+		func: 'lch($lightness $chrome $hue $alpha)',
+		insertText: 'lch(${1:lightness} ${2:chrome} ${3:hue} ${4:alpha})',
+		desc: l10n.t('css.builtin.lab', 'Creates a Color from Lightness, Chroma, Hue and alpha values.')
+	},
+	{
+		label: 'lch relative',
+		func: 'lch(from $color $lightness $chrome $hue $alpha)',
+		insertText: 'lch(from ${1:color} ${2:lightness} ${3:chrome} ${4:hue} ${5:alpha})',
+		desc: l10n.t('css.builtin.lab', 'Creates a Color from Lightness, Chroma, Hue and alpha values of another Color.')
+	}
+
 ];
 
-const colorFunctionNameRegExp = /^(rgb|rgba|hsl|hsla|hwb)$/i;
+const colorFunctionNameRegExp = /^(rgb|rgba|hsl|hsla|hwb|lab|lch)$/i;
 
 export const colors: { [name: string]: string } = {
 	aliceblue: '#f0f8ff',
@@ -296,7 +321,7 @@ export const colorKeywords: { [name: string]: string } = {
 
 const colorKeywordsRegExp = new RegExp(`^(${Object.keys(colorKeywords).join('|')})$`, "i");
 
-function getNumericValue(node: nodes.Node, factor: number) {
+function getNumericValue(node: nodes.Node, factor: number, lowerLimit: number = 0, upperLimit: number = 1) {
 	const val = node.getText();
 	const m = val.match(/^([-+]?[0-9]*\.?[0-9]+)(%?)$/);
 	if (m) {
@@ -304,7 +329,7 @@ function getNumericValue(node: nodes.Node, factor: number) {
 			factor = 100.0;
 		}
 		const result = parseFloat(m[1]) / factor;
-		if (result >= 0 && result <= 1) {
+		if (result >= lowerLimit && result <= upperLimit) {
 			return result;
 		}
 	}
@@ -533,6 +558,186 @@ export function hwbFromColor(rgba: Color): HWBA {
 	};
 }
 
+export interface XYZ { x: number; y: number; z: number; alpha: number; }
+
+export interface RGB { r: number; g: number; b: number; alpha: number; }
+
+export function xyzFromLAB(lab: LAB): XYZ {
+	const xyz: XYZ = {
+		x: 0,
+		y: 0,
+		z: 0,
+		alpha: lab.alpha ?? 1
+	};
+	xyz.y = (lab.l + 16.0) / 116.0;
+	xyz.x = (lab.a / 500.0) + xyz.y;
+	xyz.z = xyz.y - (lab.b / 200.0);
+	let key: keyof XYZ;
+
+	for (key in xyz) {
+		let pow = xyz[key] * xyz[key] * xyz[key];
+		if (pow > 0.008856) {
+			xyz[key] = pow;
+		} else {
+			xyz[key] = (xyz[key] - 16.0 / 116.0) / 7.787;
+		}
+	}
+
+	xyz.x = xyz.x * 95.047;
+	xyz.y = xyz.y * 100.0;
+	xyz.z = xyz.z * 108.883;
+	return xyz;
+}
+
+export function xyzToRGB(xyz: XYZ): Color {
+	const x = xyz.x / 100;
+	const y = xyz.y / 100;
+	const z = xyz.z / 100;
+
+	const r = 3.2406254773200533 * x - 1.5372079722103187 * y - 0.4986285986982479 * z;
+	const g = -0.9689307147293197 * x + 1.8757560608852415 * y + 0.041517523842953964 * z;
+	const b = 0.055710120445510616 * x + -0.2040210505984867 * y + 1.0569959422543882 * z;
+
+	const compand = (c: number) => {
+		return c <= 0.0031308 ?
+			12.92 * c :
+			Math.min(1.055 * Math.pow(c, 1 / 2.4) - 0.055, 1);
+	}
+
+	return {
+		red: Math.round(compand(r) * 255.0),
+		blue: Math.round(compand(b) * 255.0),
+		green: Math.round(compand(g) * 255.0),
+		alpha: xyz.alpha
+	};
+}
+
+export function RGBtoXYZ(rgba: Color): XYZ {
+	let r: number = rgba.red,
+		g: number = rgba.green,
+		b: number = rgba.blue;
+
+	if (r > 0.04045) {
+		r = Math.pow((r + 0.055) / 1.055, 2.4);
+	} else {
+		r = r / 12.92;
+	}
+	if (g > 0.04045) {
+		g = Math.pow((g + 0.055) / 1.055, 2.4);
+	} else {
+		g = g / 12.92;
+	}
+	if (b > 0.04045) {
+		b = Math.pow((b + 0.055) / 1.055, 2.4);
+	} else {
+		b = b / 12.92;
+	}
+	r = r * 100;
+	g = g * 100;
+	b = b * 100;
+
+	//Observer = 2°, Illuminant = D65
+	const x = r * 0.4124 + g * 0.3576 + b * 0.1805;
+	const y = r * 0.2126 + g * 0.7152 + b * 0.0722;
+	const z = r * 0.0193 + g * 0.1192 + b * 0.9505;
+	return { x, y, z, alpha: rgba.alpha };
+}
+
+export function XYZtoLAB(xyz: XYZ, round: Boolean = true): LAB {
+	const ref_X = 95.047, ref_Y = 100.000, ref_Z = 108.883;
+
+	let x: number = xyz.x / ref_X,
+		y: number = xyz.y / ref_Y,
+		z: number = xyz.z / ref_Z;
+
+	if (x > 0.008856) {
+		x = Math.pow(x, 1 / 3);
+	} else {
+		x = (7.787 * x) + (16 / 116);
+	}
+	if (y > 0.008856) {
+		y = Math.pow(y, 1 / 3);
+	} else {
+		y = (7.787 * y) + (16 / 116);
+	}
+	if (z > 0.008856) {
+		z = Math.pow(z, 1 / 3);
+	} else {
+		z = (7.787 * z) + (16 / 116);
+	}
+	const l: number = (116 * y) - 16,
+		a: number = 500 * (x - y),
+		b: number = 200 * (y - z);
+	if (round) {
+		return {
+			l: Math.round((l + Number.EPSILON) * 100) / 100,
+			a: Math.round((a + Number.EPSILON) * 100) / 100,
+			b: Math.round((b + Number.EPSILON) * 100) / 100,
+			alpha: xyz.alpha
+		};
+	} else {
+		return {
+			l, a, b,
+			alpha: xyz.alpha
+		};
+	}
+}
+
+export function labFromColor(rgba: Color, round: Boolean = true): LAB {
+	const xyz: XYZ = RGBtoXYZ(rgba);
+	const lab: LAB = XYZtoLAB(xyz, round);
+	return lab;
+}
+export function lchFromColor(rgba: Color): LCH {
+	const lab: LAB = labFromColor(rgba, false);
+	const c: number = Math.sqrt(Math.pow(lab.a, 2) + Math.pow(lab.b, 2));
+	let h: number = Math.atan2(lab.b, lab.a) * (180 / Math.PI);
+	while (h < 0) {
+		h = h + 360;
+	}
+	return {
+		l: Math.round((lab.l + Number.EPSILON) * 100) / 100,
+		c: Math.round((c + Number.EPSILON) * 100) / 100,
+		h: Math.round((h + Number.EPSILON) * 100) / 100,
+		alpha: lab.alpha
+	};
+}
+
+export function colorFromLAB(l: number, a: number, b: number, alpha: number = 1.0): Color {
+	const lab: LAB = {
+		l,
+		a,
+		b,
+		alpha
+	};
+	const xyz = xyzFromLAB(lab);
+	const rgb = xyzToRGB(xyz);
+	return {
+		red: (rgb.red >= 0 ? (rgb.red <= 255 ? rgb.red : 255) : 0) / 255.0,
+		green: (rgb.green >= 0 ? (rgb.green <= 255 ? rgb.green : 255) : 0) / 255.0,
+		blue: (rgb.blue >= 0 ? (rgb.blue <= 255 ? rgb.blue : 255) : 0) / 255.0,
+		alpha
+	};
+}
+
+export interface LAB { l: number; a: number; b: number; alpha?: number; }
+
+export function labFromLCH(l: number, c: number, h: number, alpha: number = 1.0): LAB {
+	return {
+		l: l,
+		a: c * Math.cos(h * (Math.PI / 180)),
+		b: c * Math.sin(h * (Math.PI / 180)),
+		alpha: alpha
+	};
+}
+
+export function colorFromLCH(l: number, c: number, h: number, alpha: number = 1.0): Color {
+	const lab: LAB = labFromLCH(l, c, h, alpha);
+	return colorFromLAB(lab.l, lab.a, lab.b, alpha);
+}
+
+export interface LCH { l: number; c: number; h: number; alpha?: number; }
+
 export function getColorValue(node: nodes.Node): Color | null {
 	if (node.type === nodes.NodeType.HexColorValue) {
 		const text = node.getText();
@@ -578,6 +783,18 @@ export function getColorValue(node: nodes.Node): Color | null {
 				const w = getNumericValue(colorValues[1], 100.0);
 				const b = getNumericValue(colorValues[2], 100.0);
 				return colorFromHWB(h, w, b, alpha);
+			} else if (name === 'lab') {
+				// Reference: https://mina86.com/2021/srgb-lab-lchab-conversions/
+				const l = getNumericValue(colorValues[0], 100.0);
+				// Since these two values can be negative, a lower limit of -1 has been added
+				const a = getNumericValue(colorValues[1], 125.0, -1);
+				const b = getNumericValue(colorValues[2], 125.0, -1);
+				return colorFromLAB(l * 100, a * 125, b * 125, alpha);
+			} else if (name === 'lch') {
+				const l = getNumericValue(colorValues[0], 100.0);
+				const c = getNumericValue(colorValues[1], 230.0);
+				const h = getAngle(colorValues[2]);
+				return colorFromLCH(l * 100, c * 230, h, alpha);
 			}
 		} catch (e) {
 			// parse error on numeric value
diff --git a/src/parser/cssNodes.ts b/src/parser/cssNodes.ts
index 7f1cd11b..d9a2e66c 100644
--- a/src/parser/cssNodes.ts
+++ b/src/parser/cssNodes.ts
@@ -101,6 +101,7 @@ export enum NodeType {
 	PropertyAtRule,
 	Container,
 	ModuleConfig,
+	SelectorList
 }
 
 export enum ReferenceType {
diff --git a/src/parser/cssParser.ts b/src/parser/cssParser.ts
index 37ea6f6a..bd09920b 100644
--- a/src/parser/cssParser.ts
+++ b/src/parser/cssParser.ts
@@ -1688,7 +1688,7 @@ export class Parser {
 		if (node) {
 			if (!this.hasWhitespace() && this.accept(TokenType.ParenthesisL)) {
 				const tryAsSelector = () => {
-					const selectors = this.create(nodes.Node);
+					const selectors = this.createNode(nodes.NodeType.SelectorList);
 					if (!selectors.addChild(this._parseSelector(true))) {
 						return null;
 					}
@@ -1704,9 +1704,11 @@ export class Parser {
 
 				let hasSelector = node.addChild(this.try(tryAsSelector));
 				if (!hasSelector) {
-					if (
-						node.addChild(this._parseBinaryExpr()) &&
-						this.acceptIdent('of') &&
+					// accept the <an+b> syntax (not a proper expression) https://drafts.csswg.org/css-syntax/#anb
+					while (!this.peekIdent('of') && (node.addChild(this._parseTerm()) || node.addChild(this._parseOperator()))) {
+						// loop
+					}
+					if (this.acceptIdent('of') &&
 						!node.addChild(this.try(tryAsSelector))
 					) {
 						return this.finish(node, ParseError.SelectorExpected);
diff --git a/src/parser/cssScanner.ts b/src/parser/cssScanner.ts
index 049c18ed..1100dee3 100644
--- a/src/parser/cssScanner.ts
+++ b/src/parser/cssScanner.ts
@@ -447,15 +447,21 @@ export class Scanner {
 	}
 
 	private _number(): boolean {
-		let npeek = 0, ch: number;
-		if (this.stream.peekChar() === _DOT) {
-			npeek = 1;
+		let npeek = 0;
+		let hasDot = false;
+		const peekFirst = this.stream.peekChar();
+		if (peekFirst === _PLS || peekFirst === _MIN) {
+			npeek++;
 		}
-		ch = this.stream.peekChar(npeek);
+		if (this.stream.peekChar(npeek) === _DOT) {
+			npeek++;
+			hasDot = true;
+		}
+		const ch = this.stream.peekChar(npeek);
 		if (ch >= _0 && ch <= _9) {
 			this.stream.advance(npeek + 1);
 			this.stream.advanceWhileChar((ch) => {
-				return ch >= _0 && ch <= _9 || npeek === 0 && ch === _DOT;
+				return ch >= _0 && ch <= _9 || !hasDot && ch === _DOT;
 			});
 			return true;
 		}
diff --git a/src/services/cssNavigation.ts b/src/services/cssNavigation.ts
index 68b718ce..21cc8fec 100644
--- a/src/services/cssNavigation.ts
+++ b/src/services/cssNavigation.ts
@@ -11,7 +11,7 @@ import {
 import * as l10n from '@vscode/l10n';
 import * as nodes from '../parser/cssNodes';
 import { Symbols } from '../parser/cssSymbolScope';
-import { getColorValue, hslFromColor, hwbFromColor } from '../languageFacts/facts';
+import { getColorValue, hslFromColor, hwbFromColor, labFromColor, lchFromColor } from '../languageFacts/facts';
 import { startsWith } from '../utils/strings';
 import { dirname, joinPath } from '../utils/resources';
 
@@ -343,6 +343,21 @@ export class CSSNavigation {
 		}
 		result.push({ label: label, textEdit: TextEdit.replace(range, label) });
 
+		const lab = labFromColor(color);
+		if (lab.alpha === 1) {
+			label = `lab(${lab.l}% ${lab.a} ${lab.b})`;
+		} else {
+			label = `lab(${lab.l}% ${lab.a} ${lab.b} / ${lab.alpha})`;
+		}
+		result.push({ label: label, textEdit: TextEdit.replace(range, label) });
+
+		const lch = lchFromColor(color);
+		if (lab.alpha === 1) {
+			label = `lch(${lch.l}% ${lch.c} ${lch.h})`;
+		} else {
+			label = `lch(${lch.l}% ${lch.c} ${lch.h} / ${lch.alpha})`;
+		}
+		result.push({ label: label, textEdit: TextEdit.replace(range, label) });
 		return result;
 	}
 
diff --git a/src/services/selectorPrinting.ts b/src/services/selectorPrinting.ts
index 6f96d0f6..9e30c093 100644
--- a/src/services/selectorPrinting.ts
+++ b/src/services/selectorPrinting.ts
@@ -468,9 +468,10 @@ export class SelectorPrinting {
 							// https://www.w3.org/TR/selectors-4/#the-nth-child-pseudo
 							specificity.attr++;
 
-							// 23 = Binary Expression.
-							if (childElements.length === 3 && childElements[1].type === 23) {
-								let mostSpecificListItem = calculateMostSpecificListItem(childElements[2].getChildren());
+							const lastChild = childElements[childElements.length - 1];
+							if (childElements.length > 2 && lastChild.type === nodes.NodeType.SelectorList) {
+								// e.g :nth-child(-n+3 of li.important)
+								let mostSpecificListItem = calculateMostSpecificListItem(lastChild.getChildren());
 
 								specificity.id += mostSpecificListItem.id;
 								specificity.attr += mostSpecificListItem.attr;
diff --git a/src/test/css/languageFacts.test.ts b/src/test/css/languageFacts.test.ts
index 33b9f773..d52ff7fb 100644
--- a/src/test/css/languageFacts.test.ts
+++ b/src/test/css/languageFacts.test.ts
@@ -5,7 +5,7 @@
 'use strict';
 
 import * as assert from 'assert';
-import { isColorValue, getColorValue, getBrowserLabel, colorFrom256RGB, colorFromHex, hexDigit, hslFromColor, HSLA, hwbFromColor, HWBA, colorFromHWB, colorFromHSL } from '../../languageFacts/facts';
+import { isColorValue, getColorValue, getBrowserLabel, colorFrom256RGB, colorFromHex, hexDigit, hslFromColor, HSLA, XYZ, LAB, xyzToRGB, xyzFromLAB, hwbFromColor, HWBA, colorFromHWB, colorFromHSL, colorFromLAB, labFromLCH, colorFromLCH, labFromColor, RGBtoXYZ, lchFromColor, LCH } from '../../languageFacts/facts';
 import { Parser } from '../../parser/cssParser';
 import * as nodes from '../../parser/cssNodes';
 import { TextDocument, Color } from '../../cssLanguageTypes';
@@ -69,7 +69,50 @@ function assertHWBValue(actual: HWBA, expected: HWBA) {
 	assert.deepEqual(actual, expected);
 }
 
+function assertXYZValue(actual: XYZ, expected: XYZ) {
+	if (actual && expected) {
+		const xDiff = Math.abs(actual.x - expected.x);
+		const yDiff = Math.abs(actual.y - expected.y);
+		const zDiff = Math.abs(actual.z - expected.z);
+		const aDiff = Math.abs((actual.alpha - expected.alpha) * 100);
+		if (xDiff < 1 && yDiff < 1 && zDiff < 1 && aDiff < 1) {
+			return;
+		}
+	}
+	assert.deepEqual(actual, expected);
+}
+
+function assertLABValue(actual: LAB, expected: LAB) {
+	if (actual && expected) {
+		const lDiff = Math.abs(actual.l - expected.l);
+		const aDiff = Math.abs(actual.a - expected.a);
+		const bDiff = Math.abs(actual.b - expected.b);
+		let alphaDiff = 0;
+		if (actual.alpha && expected.alpha) {
+			alphaDiff = Math.abs((actual.alpha - expected.alpha) * 100);
+		}
+		if (lDiff < 1 && aDiff < 1 && bDiff < 1 && alphaDiff < 1) {
+			return;
+		}
+	}
+	assert.deepEqual(actual, expected);
+}
 
+function assertLCHValue(actual: LCH, expected: LCH) {
+	if (actual && expected) {
+		const lDiff = Math.abs(actual.l - expected.l);
+		const cDiff = Math.abs(actual.c - expected.c);
+		const hDiff = Math.abs(actual.h - expected.h);
+		let alphaDiff = 0;
+		if (actual.alpha && expected.alpha) {
+			alphaDiff = Math.abs((actual.alpha - expected.alpha) * 100);
+		}
+		if (lDiff < 1 && cDiff < 1 && hDiff < 1 && alphaDiff < 1) {
+			return;
+		}
+	}
+	assert.deepEqual(actual, expected);
+}
 suite('CSS - Language Facts', () => {
 
 	const cssDataManager = new CSSDataManager({ useDefaultDataProvider: true });
@@ -128,6 +171,11 @@ suite('CSS - Language Facts', () => {
 		assertColor(parser, '#main { color: hsla(240 100% 50% / .05) }', 'hsl', colorFrom256RGB(0, 0, 255, 0.05));
 		assertColor(parser, '#main { color: hwb(120 0% 0% / .05) }', 'hwb', colorFrom256RGB(0, 255, 0, 0.05));
 		assertColor(parser, '#main { color: hwb(36 33% 35%) }', 'hwb', colorFrom256RGB(166, 133, 84));
+		assertColor(parser, '#main { color: lab(90 100 100) }', 'lab', colorFrom256RGB(255, 112, 0));
+		assertColor(parser, '#main { color: lab(90% 50 -50) }', 'lab', colorFrom256RGB(255, 195, 255));
+		assertColor(parser, '#main { color: lab(46.41 39.24 33.51) }', 'lab', colorFrom256RGB(180, 79, 56));
+		assertColor(parser, '#main { color: lab(46.41 -39.24 33.51) }', 'lab', colorFrom256RGB(50, 125, 50));
+		assertColor(parser, '#main { color: lch(46.41, 51.60, 139.50) }', 'lch', colorFrom256RGB(50, 125, 50));
 	});
 
 	test('hexDigit', function () {
@@ -229,4 +277,37 @@ suite('CSS - Language Facts', () => {
 		assertColorValue(colorFromHSL(118, 0.98, 0.5), colorFrom256RGB(11, 252, 3), 'hsl(118, 98%, 50%)');
 		assertColorValue(colorFromHSL(120, 0.83, 0.95), colorFrom256RGB(232, 253, 232), 'hsl(120, 83%, 95%)');
 	});
+
+	test('xyzFromLAB', function () {
+		// verified with https://www.colorspaceconverter.com/converter/lab-to-xyz
+		assertXYZValue(xyzFromLAB({ l: 46.41, a: -39.24, b: 33.51 }), { x: 9.22, y: 15.58, z: 5.54, alpha: 1 });
+		assertXYZValue(xyzFromLAB({ l: 50, a: -50, b: 50 }), { x: 9.8, y: 18.42, z: 3.53, alpha: 1 });
+		assertXYZValue(xyzFromLAB({ l: 90, a: 50, b: -50 }), { x: 99.03, y: 76.3, z: 171.63, alpha: 1 });
+	});
+
+	test('xyzToRGB', function () {
+		// verified with https://www.colorspaceconverter.com/converter/xyz-to-rgb
+		assertColorValue(xyzToRGB({ x: 9.22, y: 15.58, z: 5.54, alpha: 1 }), { red: 50, green: 125, blue: 50, alpha: 1 }, 'xyz(9.22, 15.58, 5.54)');
+		assertColorValue(xyzToRGB({ x: 9.8, y: 18.42, z: 3.53, alpha: 1 }), { red: 35, green: 137, blue: 16, alpha: 1 }, '2');
+		assertColorValue(xyzToRGB({ x: 99, y: 76, z: 71, alpha: 1 }), { red: 255, green: 187, blue: 211, alpha: 1 }, '3');
+
+	});
+	test('LABToRGB', function () {
+		assertColorValue(colorFromLAB(46.41, -39.24, 33.51), colorFrom256RGB(50, 125, 50), 'lab(46.41, -39.24, 33.51)');
+	});
+	test('labFromLCH', function () {
+		assertLABValue(labFromLCH(46.41, 51.60, 139.50), { l: 46.41, a: -39.24, b: 33.51, alpha: 1 });
+	});
+	test('LCHtoRGB', function () {
+		assertColorValue(colorFromLCH(46.41, 51.60, 139.50), colorFrom256RGB(50, 125, 50), 'lch(46.41, 51.60, 139.50)');
+	});
+	test('labFromColor', function () {
+		assertLABValue(labFromColor(colorFrom256RGB(50, 125, 50)), { l: 46.41, a: -39.24, b: 33.51, alpha: 1 });
+	});
+	test('RGBToXYZ', function () {
+		assertXYZValue(RGBtoXYZ(colorFrom256RGB(50, 125, 50)), { x: 9.22, y: 15.58, z: 5.54, alpha: 1 });
+	});
+	test('RGBToLCH', function () {
+		assertLCHValue(lchFromColor(colorFrom256RGB(50, 125, 50)), { l: 46.41, c: 51.60, h: 139.50 });
+	});
 });
diff --git a/src/test/css/navigation.test.ts b/src/test/css/navigation.test.ts
index 8f1a5b0f..1c1a051f 100644
--- a/src/test/css/navigation.test.ts
+++ b/src/test/css/navigation.test.ts
@@ -479,9 +479,9 @@ suite('CSS - Navigation', () => {
 		});
 
 		test('color presentations', function () {
-			const ls = getCSSLS();
-			assertColorPresentations(ls, colorFrom256RGB(255, 0, 0), 'rgb(255, 0, 0)', '#ff0000', 'hsl(0, 100%, 50%)', 'hwb(0 0% 0%)');
-			assertColorPresentations(ls, colorFrom256RGB(77, 33, 111, 0.5), 'rgba(77, 33, 111, 0.5)', '#4d216f80', 'hsla(274, 54%, 28%, 0.5)', 'hwb(274 13% 56% / 0.5)');
+			let ls = getCSSLS();
+			assertColorPresentations(ls, colorFrom256RGB(255, 0, 0), 'rgb(255, 0, 0)', '#ff0000', 'hsl(0, 100%, 50%)', 'hwb(0 0% 0%)', 'lab(53.23% 80.11 67.22)', 'lch(53.23% 104.58 40)');
+			assertColorPresentations(ls, colorFrom256RGB(77, 33, 111, 0.5), 'rgba(77, 33, 111, 0.5)', '#4d216f80', 'hsla(274, 54%, 28%, 0.5)', 'hwb(274 13% 56% / 0.5)', 'lab(23.04% 35.9 -36.96 / 0.5)', 'lch(23.04% 51.53 314.16 / 0.5)');
 		});
 	});
 });