color-computed-hsl.html

<!DOCTYPE html>

<html>

<head>

<meta charset="utf-8">

<title>CSS Color Level 4: Computation of colors using HSL notation</title>

<link rel="help" href="https://drafts.csswg.org/css-color-4/#the-hsl-notation">

<link rel="help" href="https://drafts.csswg.org/css-color-4/#resolving-sRGB-values">

<link rel="help" href="https://drafts.csswg.org/css-color-4/#serializing-sRGB-values">

<link rel="author" title="Chris Nardi" href="mailto:csnardi1@gmail.com">

<script src="/resources/testharness.js"></script>

<script src="/resources/testharnessreport.js"></script>

<script src="/css/support/computed-testcommon.js"></script>

</head>

<body>

<div id="container">

  <div id="target"></div>

</div>

<style>

  #container {

    color: rgb(255, 0, 0);

</style>

<script>

tests = [

    ["hsl(120 30% 50%)", "rgb(89, 166, 89)"],

    ["hsl(120 30% 50% / 0.5)", "rgba(89, 166, 89, 0.5)"],

    ["hsl(120 30% 50% / 50%)", "rgba(89, 166, 89, 0.5)"],

    ["hsl(none none none)", "rgb(0, 0, 0)"],

    ["hsl(0 0% 0%)", "rgb(0, 0, 0)"],

    ["hsl(none none none / none)", "rgba(0, 0, 0, 0)"],

    ["hsl(0 0% 0% / 0)", "rgba(0, 0, 0, 0)"],

    ["hsla(none none none)", "rgb(0, 0, 0)"],

    ["hsla(0 0% 0%)", "rgb(0, 0, 0)"],

    ["hsla(none none none / none)", "rgba(0, 0, 0, 0)"],

    ["hsla(0 0% 0% / 0)", "rgba(0, 0, 0, 0)"],

    ["hsl(120 none none)", "rgb(0, 0, 0)"],

    ["hsl(120 0% 0%)", "rgb(0, 0, 0)"],

    ["hsl(120 80% none)", "rgb(0, 0, 0)"],

    ["hsl(120 80% 0%)", "rgb(0, 0, 0)"],

    ["hsl(120 none 50%)", "rgb(128, 128, 128)"],

    ["hsl(120 0% 50%)", "rgb(128, 128, 128)"],

    ["hsl(120 100% 50% / none)", "rgba(0, 255, 0, 0)"],

    ["hsl(120 100% 50% / 0)", "rgba(0, 255, 0, 0)"],

    ["hsl(120 100% 50% / 0%)", "rgba(0, 255, 0, 0)"],

    ["hsl(none 100% 50%)", "rgb(255, 0, 0)"],

    ["hsl(0 100% 50%)", "rgb(255, 0, 0)"],

    ["HSL(0, 0%, 0%)", "rgb(0, 0, 0)", "Capitalization should not affect parsing"],

    ["hsL(0, 100%, 50%)", "rgb(255, 0, 0)", "Capitalization should not affect parsing"],

    ["hsl(60, 100%, 37.5%)", "rgb(191, 191, 0)", "Valid numbers should be parsed"],

    ["hsl(780, 100%, 37.5%)", "rgb(191, 191, 0)", "Angles are represented as a part of a circle and wrap around"],

    ["hsl(-300, 100%, 37.5%)", "rgb(191, 191, 0)", "Angles are represented as a part of a circle and wrap around"],

    ["hsl(300, 50%, 50%)", "rgb(191, 64, 191)", "Valid numbers should be parsed"],

    ["hsl(30deg, 100%, 100%)", "rgb(255, 255, 255)", "Angles are accepted in HSL/HSLA"],

    ["hsl(0, 0%, 0%, 0%)", "rgba(0, 0, 0, 0)", "HSL and HSLA are synonyms"],

    ["HSLA(-300, 100%, 37.5%, 1)", "rgb(191, 191, 0)", "Angles are represented as a part of a circle and wrap around"],

    ["hsLA(-300, 100%, 37.5%, 12)", "rgb(191, 191, 0)", "Invalid alpha values should be clamped to 0 and 1 respectively"],

    ["hsla(-300, 100%, 37.5%, 0.2)", "rgba(191, 191, 0, 0.2)", "Angles are represented as a part of a circle and wrap around"],

    ["hsla(-300, 100%, 37.5%, 0)", "rgba(191, 191, 0, 0)", "Angles are represented as a part of a circle and wrap around"],

    ["hsla(-300, 100%, 37.5%, -3)", "rgba(191, 191, 0, 0)", "Invalid alpha values should be clamped to 0 and 1 respectively"],

    ["hsla(0, 0%, 0%, 50%)", "rgba(0, 0, 0, 0.5)", "Percent alpha values are accepted in hsl/hsla"],

    ["hsla(30deg, 100%, 100%, 1)", "rgb(255, 255, 255)", "Angles are accepted in HSL/HSLA"],

    ["hsl(0, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 12.5%)", "rgb(36, 28, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 12.5%, 0)", "rgba(36, 28, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 12.5%, 0.2)", "rgba(36, 28, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 12.5%, 1)", "rgb(36, 28, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 25%)", "rgb(72, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 25%, 0)", "rgba(72, 56, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 25%, 0.2)", "rgba(72, 56, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 25%, 1)", "rgb(72, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 37.5%)", "rgb(108, 84, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 37.5%, 0)", "rgba(108, 84, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 37.5%, 0.2)", "rgba(108, 84, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 37.5%, 1)", "rgb(108, 84, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 50%)", "rgb(143, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 50%, 0)", "rgba(143, 112, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 50%, 0.2)", "rgba(143, 112, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 50%, 1)", "rgb(143, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 62.5%)", "rgb(171, 147, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 62.5%, 0)", "rgba(171, 147, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 62.5%, 0.2)", "rgba(171, 147, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 62.5%, 1)", "rgb(171, 147, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 75%)", "rgb(199, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 75%, 0)", "rgba(199, 183, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 75%, 0.2)", "rgba(199, 183, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 75%, 1)", "rgb(199, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 87.5%)", "rgb(227, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 87.5%, 0)", "rgba(227, 219, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 87.5%, 0.2)", "rgba(227, 219, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 87.5%, 1)", "rgb(227, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 12.5%)", "rgb(40, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 12.5%, 0)", "rgba(40, 24, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 12.5%, 0.2)", "rgba(40, 24, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 12.5%, 1)", "rgb(40, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 25%)", "rgb(80, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 25%, 0)", "rgba(80, 48, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 25%, 0.2)", "rgba(80, 48, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 25%, 1)", "rgb(80, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 37.5%)", "rgb(120, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 37.5%, 0)", "rgba(120, 72, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 37.5%, 0.2)", "rgba(120, 72, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 37.5%, 1)", "rgb(120, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 50%)", "rgb(159, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 50%, 0)", "rgba(159, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 50%, 0.2)", "rgba(159, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 50%, 1)", "rgb(159, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 62.5%)", "rgb(183, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 62.5%, 0)", "rgba(183, 135, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 62.5%, 0.2)", "rgba(183, 135, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 62.5%, 1)", "rgb(183, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 75%)", "rgb(207, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 75%, 0)", "rgba(207, 175, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 75%, 0.2)", "rgba(207, 175, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 75%, 1)", "rgb(207, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 87.5%)", "rgb(231, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 87.5%, 0)", "rgba(231, 215, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 87.5%, 0.2)", "rgba(231, 215, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 87.5%, 1)", "rgb(231, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 12.5%)", "rgb(44, 20, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 12.5%, 0)", "rgba(44, 20, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 12.5%, 0.2)", "rgba(44, 20, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 12.5%, 1)", "rgb(44, 20, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 25%)", "rgb(88, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 25%, 0)", "rgba(88, 40, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 25%, 0.2)", "rgba(88, 40, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 25%, 1)", "rgb(88, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 37.5%)", "rgb(131, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 37.5%, 0)", "rgba(131, 60, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 37.5%, 0.2)", "rgba(131, 60, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 37.5%, 1)", "rgb(131, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 50%)", "rgb(175, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 50%, 0)", "rgba(175, 80, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 50%, 0.2)", "rgba(175, 80, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 50%, 1)", "rgb(175, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 62.5%)", "rgb(195, 124, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 62.5%, 0)", "rgba(195, 124, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 62.5%, 0.2)", "rgba(195, 124, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 62.5%, 1)", "rgb(195, 124, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 75%)", "rgb(215, 167, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 75%, 0)", "rgba(215, 167, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 75%, 0.2)", "rgba(215, 167, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 75%, 1)", "rgb(215, 167, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 87.5%)", "rgb(235, 211, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 87.5%, 0)", "rgba(235, 211, 211, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 87.5%, 0.2)", "rgba(235, 211, 211, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 87.5%, 1)", "rgb(235, 211, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 12.5%)", "rgb(48, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 12.5%, 0)", "rgba(48, 16, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 12.5%, 0.2)", "rgba(48, 16, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 12.5%, 1)", "rgb(48, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 25%)", "rgb(96, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 25%, 0)", "rgba(96, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 25%, 0.2)", "rgba(96, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 25%, 1)", "rgb(96, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 37.5%)", "rgb(143, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 37.5%, 0)", "rgba(143, 48, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 37.5%, 0.2)", "rgba(143, 48, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 37.5%, 1)", "rgb(143, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 50%)", "rgb(191, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 50%, 0)", "rgba(191, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 50%, 0.2)", "rgba(191, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 50%, 1)", "rgb(191, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 62.5%)", "rgb(207, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 62.5%, 0)", "rgba(207, 112, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 62.5%, 0.2)", "rgba(207, 112, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 62.5%, 1)", "rgb(207, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 75%)", "rgb(223, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 75%, 0)", "rgba(223, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 75%, 0.2)", "rgba(223, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 75%, 1)", "rgb(223, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 87.5%)", "rgb(239, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 87.5%, 0)", "rgba(239, 207, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 87.5%, 0.2)", "rgba(239, 207, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 87.5%, 1)", "rgb(239, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 12.5%)", "rgb(52, 12, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 12.5%, 0)", "rgba(52, 12, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 12.5%, 0.2)", "rgba(52, 12, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 12.5%, 1)", "rgb(52, 12, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 25%)", "rgb(104, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 25%, 0)", "rgba(104, 24, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 25%, 0.2)", "rgba(104, 24, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 25%, 1)", "rgb(104, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 37.5%)", "rgb(155, 36, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 37.5%, 0)", "rgba(155, 36, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 37.5%, 0.2)", "rgba(155, 36, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 37.5%, 1)", "rgb(155, 36, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 50%)", "rgb(207, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 50%, 0)", "rgba(207, 48, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 50%, 0.2)", "rgba(207, 48, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 50%, 1)", "rgb(207, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 62.5%)", "rgb(219, 100, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 62.5%, 0)", "rgba(219, 100, 100, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 62.5%, 0.2)", "rgba(219, 100, 100, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 62.5%, 1)", "rgb(219, 100, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 75%)", "rgb(231, 151, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 75%, 0)", "rgba(231, 151, 151, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 75%, 0.2)", "rgba(231, 151, 151, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 75%, 1)", "rgb(231, 151, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 87.5%)", "rgb(243, 203, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 87.5%, 0)", "rgba(243, 203, 203, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 87.5%, 0.2)", "rgba(243, 203, 203, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 87.5%, 1)", "rgb(243, 203, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 12.5%)", "rgb(56, 8, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 12.5%, 0)", "rgba(56, 8, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 12.5%, 0.2)", "rgba(56, 8, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 12.5%, 1)", "rgb(56, 8, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 25%)", "rgb(112, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 25%, 0)", "rgba(112, 16, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 25%, 0.2)", "rgba(112, 16, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 25%, 1)", "rgb(112, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 37.5%)", "rgb(167, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 37.5%, 0)", "rgba(167, 24, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 37.5%, 0.2)", "rgba(167, 24, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 37.5%, 1)", "rgb(167, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 50%)", "rgb(223, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 50%, 0)", "rgba(223, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 50%, 0.2)", "rgba(223, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 50%, 1)", "rgb(223, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 62.5%)", "rgb(231, 88, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 62.5%, 0)", "rgba(231, 88, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 62.5%, 0.2)", "rgba(231, 88, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 62.5%, 1)", "rgb(231, 88, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 75%)", "rgb(239, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 75%, 0)", "rgba(239, 143, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 75%, 0.2)", "rgba(239, 143, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 75%, 1)", "rgb(239, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 87.5%)", "rgb(247, 199, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 87.5%, 0)", "rgba(247, 199, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 87.5%, 0.2)", "rgba(247, 199, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 87.5%, 1)", "rgb(247, 199, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 12.5%)", "rgb(60, 4, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 12.5%, 0)", "rgba(60, 4, 4, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 12.5%, 0.2)", "rgba(60, 4, 4, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 12.5%, 1)", "rgb(60, 4, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 25%)", "rgb(120, 8, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 25%, 0)", "rgba(120, 8, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 25%, 0.2)", "rgba(120, 8, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 25%, 1)", "rgb(120, 8, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 37.5%)", "rgb(179, 12, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 37.5%, 0)", "rgba(179, 12, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 37.5%, 0.2)", "rgba(179, 12, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 37.5%, 1)", "rgb(179, 12, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 50%)", "rgb(239, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 50%, 0)", "rgba(239, 16, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 50%, 0.2)", "rgba(239, 16, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 50%, 1)", "rgb(239, 16, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 62.5%)", "rgb(243, 76, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 62.5%, 0)", "rgba(243, 76, 76, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 62.5%, 0.2)", "rgba(243, 76, 76, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 62.5%, 1)", "rgb(243, 76, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 75%)", "rgb(247, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 75%, 0)", "rgba(247, 135, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 75%, 0.2)", "rgba(247, 135, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 75%, 1)", "rgb(247, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 87.5%)", "rgb(251, 195, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 87.5%, 0)", "rgba(251, 195, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 87.5%, 0.2)", "rgba(251, 195, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 87.5%, 1)", "rgb(251, 195, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 12.5%)", "rgb(64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 12.5%, 0)", "rgba(64, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 12.5%, 0.2)", "rgba(64, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 12.5%, 1)", "rgb(64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 25%)", "rgb(128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 25%, 0)", "rgba(128, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 25%, 0.2)", "rgba(128, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 25%, 1)", "rgb(128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 37.5%)", "rgb(191, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 37.5%, 0)", "rgba(191, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 37.5%, 0.2)", "rgba(191, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 37.5%, 1)", "rgb(191, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 50%)", "rgb(255, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 50%, 0)", "rgba(255, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 50%, 0.2)", "rgba(255, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 50%, 1)", "rgb(255, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 62.5%)", "rgb(255, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 62.5%, 0)", "rgba(255, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 62.5%, 0.2)", "rgba(255, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 62.5%, 1)", "rgb(255, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 75%)", "rgb(255, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 75%, 0)", "rgba(255, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 75%, 0.2)", "rgba(255, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 75%, 1)", "rgb(255, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 87.5%)", "rgb(255, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 87.5%, 0)", "rgba(255, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 87.5%, 0.2)", "rgba(255, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 87.5%, 1)", "rgb(255, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(0, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(0, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 12.5%)", "rgb(36, 32, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 12.5%, 0)", "rgba(36, 32, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 12.5%, 0.2)", "rgba(36, 32, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 12.5%, 1)", "rgb(36, 32, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 25%)", "rgb(72, 64, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 25%, 0)", "rgba(72, 64, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 25%, 0.2)", "rgba(72, 64, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 25%, 1)", "rgb(72, 64, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 37.5%)", "rgb(108, 96, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 37.5%, 0)", "rgba(108, 96, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 37.5%, 0.2)", "rgba(108, 96, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 37.5%, 1)", "rgb(108, 96, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 50%)", "rgb(143, 128, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 50%, 0)", "rgba(143, 128, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 50%, 0.2)", "rgba(143, 128, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 50%, 1)", "rgb(143, 128, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 62.5%)", "rgb(171, 159, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 62.5%, 0)", "rgba(171, 159, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 62.5%, 0.2)", "rgba(171, 159, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 62.5%, 1)", "rgb(171, 159, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 75%)", "rgb(199, 191, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 75%, 0)", "rgba(199, 191, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 75%, 0.2)", "rgba(199, 191, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 75%, 1)", "rgb(199, 191, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 87.5%)", "rgb(227, 223, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 87.5%, 0)", "rgba(227, 223, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 87.5%, 0.2)", "rgba(227, 223, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 87.5%, 1)", "rgb(227, 223, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 12.5%)", "rgb(40, 32, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 12.5%, 0)", "rgba(40, 32, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 12.5%, 0.2)", "rgba(40, 32, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 12.5%, 1)", "rgb(40, 32, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 25%)", "rgb(80, 64, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 25%, 0)", "rgba(80, 64, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 25%, 0.2)", "rgba(80, 64, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 25%, 1)", "rgb(80, 64, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 37.5%)", "rgb(120, 96, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 37.5%, 0)", "rgba(120, 96, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 37.5%, 0.2)", "rgba(120, 96, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 37.5%, 1)", "rgb(120, 96, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 50%)", "rgb(159, 128, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 50%, 0)", "rgba(159, 128, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 50%, 0.2)", "rgba(159, 128, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 50%, 1)", "rgb(159, 128, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 62.5%)", "rgb(183, 159, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 62.5%, 0)", "rgba(183, 159, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 62.5%, 0.2)", "rgba(183, 159, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 62.5%, 1)", "rgb(183, 159, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 75%)", "rgb(207, 191, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 75%, 0)", "rgba(207, 191, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 75%, 0.2)", "rgba(207, 191, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 75%, 1)", "rgb(207, 191, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 87.5%)", "rgb(231, 223, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 87.5%, 0)", "rgba(231, 223, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 87.5%, 0.2)", "rgba(231, 223, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 87.5%, 1)", "rgb(231, 223, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 12.5%)", "rgb(44, 32, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 12.5%, 0)", "rgba(44, 32, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 12.5%, 0.2)", "rgba(44, 32, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 12.5%, 1)", "rgb(44, 32, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 25%)", "rgb(88, 64, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 25%, 0)", "rgba(88, 64, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 25%, 0.2)", "rgba(88, 64, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 25%, 1)", "rgb(88, 64, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 37.5%)", "rgb(131, 96, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 37.5%, 0)", "rgba(131, 96, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 37.5%, 0.2)", "rgba(131, 96, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 37.5%, 1)", "rgb(131, 96, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 50%)", "rgb(175, 128, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 50%, 0)", "rgba(175, 128, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 50%, 0.2)", "rgba(175, 128, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 50%, 1)", "rgb(175, 128, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 62.5%)", "rgb(195, 159, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 62.5%, 0)", "rgba(195, 159, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 62.5%, 0.2)", "rgba(195, 159, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 62.5%, 1)", "rgb(195, 159, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 75%)", "rgb(215, 191, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 75%, 0)", "rgba(215, 191, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 75%, 0.2)", "rgba(215, 191, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 75%, 1)", "rgb(215, 191, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 87.5%)", "rgb(235, 223, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 87.5%, 0)", "rgba(235, 223, 211, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 87.5%, 0.2)", "rgba(235, 223, 211, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 87.5%, 1)", "rgb(235, 223, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 12.5%)", "rgb(48, 32, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 12.5%, 0)", "rgba(48, 32, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 12.5%, 0.2)", "rgba(48, 32, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 12.5%, 1)", "rgb(48, 32, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 25%)", "rgb(96, 64, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 25%, 0)", "rgba(96, 64, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 25%, 0.2)", "rgba(96, 64, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 25%, 1)", "rgb(96, 64, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 37.5%)", "rgb(143, 96, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 37.5%, 0)", "rgba(143, 96, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 37.5%, 0.2)", "rgba(143, 96, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 37.5%, 1)", "rgb(143, 96, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 50%)", "rgb(191, 128, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 50%, 0)", "rgba(191, 128, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 50%, 0.2)", "rgba(191, 128, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 50%, 1)", "rgb(191, 128, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 62.5%)", "rgb(207, 159, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 62.5%, 0)", "rgba(207, 159, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 62.5%, 0.2)", "rgba(207, 159, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 62.5%, 1)", "rgb(207, 159, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 75%)", "rgb(223, 191, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 75%, 0)", "rgba(223, 191, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 75%, 0.2)", "rgba(223, 191, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 75%, 1)", "rgb(223, 191, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 87.5%)", "rgb(239, 223, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 87.5%, 0)", "rgba(239, 223, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 87.5%, 0.2)", "rgba(239, 223, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 87.5%, 1)", "rgb(239, 223, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 12.5%)", "rgb(52, 32, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 12.5%, 0)", "rgba(52, 32, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 12.5%, 0.2)", "rgba(52, 32, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 12.5%, 1)", "rgb(52, 32, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 25%)", "rgb(104, 64, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 25%, 0)", "rgba(104, 64, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 25%, 0.2)", "rgba(104, 64, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 25%, 1)", "rgb(104, 64, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 37.5%)", "rgb(155, 96, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 37.5%, 0)", "rgba(155, 96, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 37.5%, 0.2)", "rgba(155, 96, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 37.5%, 1)", "rgb(155, 96, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 50%)", "rgb(207, 128, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 50%, 0)", "rgba(207, 128, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 50%, 0.2)", "rgba(207, 128, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 50%, 1)", "rgb(207, 128, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 62.5%)", "rgb(219, 159, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 62.5%, 0)", "rgba(219, 159, 100, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 62.5%, 0.2)", "rgba(219, 159, 100, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 62.5%, 1)", "rgb(219, 159, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 75%)", "rgb(231, 191, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 75%, 0)", "rgba(231, 191, 151, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 75%, 0.2)", "rgba(231, 191, 151, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 75%, 1)", "rgb(231, 191, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 87.5%)", "rgb(243, 223, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 87.5%, 0)", "rgba(243, 223, 203, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 87.5%, 0.2)", "rgba(243, 223, 203, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 87.5%, 1)", "rgb(243, 223, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 12.5%)", "rgb(56, 32, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 12.5%, 0)", "rgba(56, 32, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 12.5%, 0.2)", "rgba(56, 32, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 12.5%, 1)", "rgb(56, 32, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 25%)", "rgb(112, 64, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 25%, 0)", "rgba(112, 64, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 25%, 0.2)", "rgba(112, 64, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 25%, 1)", "rgb(112, 64, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 37.5%)", "rgb(167, 96, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 37.5%, 0)", "rgba(167, 96, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 37.5%, 0.2)", "rgba(167, 96, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 37.5%, 1)", "rgb(167, 96, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 50%)", "rgb(223, 128, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 50%, 0)", "rgba(223, 128, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 50%, 0.2)", "rgba(223, 128, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 50%, 1)", "rgb(223, 128, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 62.5%)", "rgb(231, 159, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 62.5%, 0)", "rgba(231, 159, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 62.5%, 0.2)", "rgba(231, 159, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 62.5%, 1)", "rgb(231, 159, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 75%)", "rgb(239, 191, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 75%, 0)", "rgba(239, 191, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 75%, 0.2)", "rgba(239, 191, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 75%, 1)", "rgb(239, 191, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 87.5%)", "rgb(247, 223, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 87.5%, 0)", "rgba(247, 223, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 87.5%, 0.2)", "rgba(247, 223, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 87.5%, 1)", "rgb(247, 223, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 12.5%)", "rgb(60, 32, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 12.5%, 0)", "rgba(60, 32, 4, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 12.5%, 0.2)", "rgba(60, 32, 4, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 12.5%, 1)", "rgb(60, 32, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 25%)", "rgb(120, 64, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 25%, 0)", "rgba(120, 64, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 25%, 0.2)", "rgba(120, 64, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 25%, 1)", "rgb(120, 64, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 37.5%)", "rgb(179, 96, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 37.5%, 0)", "rgba(179, 96, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 37.5%, 0.2)", "rgba(179, 96, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 37.5%, 1)", "rgb(179, 96, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 50%)", "rgb(239, 128, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 50%, 0)", "rgba(239, 128, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 50%, 0.2)", "rgba(239, 128, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 50%, 1)", "rgb(239, 128, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 62.5%)", "rgb(243, 159, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 62.5%, 0)", "rgba(243, 159, 76, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 62.5%, 0.2)", "rgba(243, 159, 76, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 62.5%, 1)", "rgb(243, 159, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 75%)", "rgb(247, 191, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 75%, 0)", "rgba(247, 191, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 75%, 0.2)", "rgba(247, 191, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 75%, 1)", "rgb(247, 191, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 87.5%)", "rgb(251, 223, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 87.5%, 0)", "rgba(251, 223, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 87.5%, 0.2)", "rgba(251, 223, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 87.5%, 1)", "rgb(251, 223, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 12.5%)", "rgb(64, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 12.5%, 0)", "rgba(64, 32, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 12.5%, 0.2)", "rgba(64, 32, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 12.5%, 1)", "rgb(64, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 25%)", "rgb(128, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 25%, 0)", "rgba(128, 64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 25%, 0.2)", "rgba(128, 64, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 25%, 1)", "rgb(128, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 37.5%)", "rgb(191, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 37.5%, 0)", "rgba(191, 96, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 37.5%, 0.2)", "rgba(191, 96, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 37.5%, 1)", "rgb(191, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 50%)", "rgb(255, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 50%, 0)", "rgba(255, 128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 50%, 0.2)", "rgba(255, 128, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 50%, 1)", "rgb(255, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 62.5%)", "rgb(255, 159, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 62.5%, 0)", "rgba(255, 159, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 62.5%, 0.2)", "rgba(255, 159, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 62.5%, 1)", "rgb(255, 159, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 75%)", "rgb(255, 191, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 75%, 0)", "rgba(255, 191, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 75%, 0.2)", "rgba(255, 191, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 75%, 1)", "rgb(255, 191, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 87.5%)", "rgb(255, 223, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 87.5%, 0)", "rgba(255, 223, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 87.5%, 0.2)", "rgba(255, 223, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 87.5%, 1)", "rgb(255, 223, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(30, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(30, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 12.5%)", "rgb(36, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 12.5%, 0)", "rgba(36, 36, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 12.5%, 0.2)", "rgba(36, 36, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 12.5%, 1)", "rgb(36, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 25%)", "rgb(72, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 25%, 0)", "rgba(72, 72, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 25%, 0.2)", "rgba(72, 72, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 25%, 1)", "rgb(72, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 37.5%)", "rgb(108, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 37.5%, 0)", "rgba(108, 108, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 37.5%, 0.2)", "rgba(108, 108, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 37.5%, 1)", "rgb(108, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 50%)", "rgb(143, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 50%, 0)", "rgba(143, 143, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 50%, 0.2)", "rgba(143, 143, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 50%, 1)", "rgb(143, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 62.5%)", "rgb(171, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 62.5%, 0)", "rgba(171, 171, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 62.5%, 0.2)", "rgba(171, 171, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 62.5%, 1)", "rgb(171, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 75%)", "rgb(199, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 75%, 0)", "rgba(199, 199, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 75%, 0.2)", "rgba(199, 199, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 75%, 1)", "rgb(199, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 87.5%)", "rgb(227, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 87.5%, 0)", "rgba(227, 227, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 87.5%, 0.2)", "rgba(227, 227, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 87.5%, 1)", "rgb(227, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 12.5%)", "rgb(40, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 12.5%, 0)", "rgba(40, 40, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 12.5%, 0.2)", "rgba(40, 40, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 12.5%, 1)", "rgb(40, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 25%)", "rgb(80, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 25%, 0)", "rgba(80, 80, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 25%, 0.2)", "rgba(80, 80, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 25%, 1)", "rgb(80, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 37.5%)", "rgb(120, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 37.5%, 0)", "rgba(120, 120, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 37.5%, 0.2)", "rgba(120, 120, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 37.5%, 1)", "rgb(120, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 50%)", "rgb(159, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 50%, 0)", "rgba(159, 159, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 50%, 0.2)", "rgba(159, 159, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 50%, 1)", "rgb(159, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 62.5%)", "rgb(183, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 62.5%, 0)", "rgba(183, 183, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 62.5%, 0.2)", "rgba(183, 183, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 62.5%, 1)", "rgb(183, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 75%)", "rgb(207, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 75%, 0)", "rgba(207, 207, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 75%, 0.2)", "rgba(207, 207, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 75%, 1)", "rgb(207, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 87.5%)", "rgb(231, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 87.5%, 0)", "rgba(231, 231, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 87.5%, 0.2)", "rgba(231, 231, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 87.5%, 1)", "rgb(231, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 12.5%)", "rgb(44, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 12.5%, 0)", "rgba(44, 44, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 12.5%, 0.2)", "rgba(44, 44, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 12.5%, 1)", "rgb(44, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 25%)", "rgb(88, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 25%, 0)", "rgba(88, 88, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 25%, 0.2)", "rgba(88, 88, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 25%, 1)", "rgb(88, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 37.5%)", "rgb(131, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 37.5%, 0)", "rgba(131, 131, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 37.5%, 0.2)", "rgba(131, 131, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 37.5%, 1)", "rgb(131, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 50%)", "rgb(175, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 50%, 0)", "rgba(175, 175, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 50%, 0.2)", "rgba(175, 175, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 50%, 1)", "rgb(175, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 62.5%)", "rgb(195, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 62.5%, 0)", "rgba(195, 195, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 62.5%, 0.2)", "rgba(195, 195, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 62.5%, 1)", "rgb(195, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 75%)", "rgb(215, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 75%, 0)", "rgba(215, 215, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 75%, 0.2)", "rgba(215, 215, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 75%, 1)", "rgb(215, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 87.5%)", "rgb(235, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 87.5%, 0)", "rgba(235, 235, 211, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 87.5%, 0.2)", "rgba(235, 235, 211, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 87.5%, 1)", "rgb(235, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 12.5%)", "rgb(48, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 12.5%, 0)", "rgba(48, 48, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 12.5%, 0.2)", "rgba(48, 48, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 12.5%, 1)", "rgb(48, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 25%)", "rgb(96, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 25%, 0)", "rgba(96, 96, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 25%, 0.2)", "rgba(96, 96, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 25%, 1)", "rgb(96, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 37.5%)", "rgb(143, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 37.5%, 0)", "rgba(143, 143, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 37.5%, 0.2)", "rgba(143, 143, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 37.5%, 1)", "rgb(143, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 50%)", "rgb(191, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 50%, 0)", "rgba(191, 191, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 50%, 0.2)", "rgba(191, 191, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 50%, 1)", "rgb(191, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 62.5%)", "rgb(207, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 62.5%, 0)", "rgba(207, 207, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 62.5%, 0.2)", "rgba(207, 207, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 62.5%, 1)", "rgb(207, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 75%)", "rgb(223, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 75%, 0)", "rgba(223, 223, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 75%, 0.2)", "rgba(223, 223, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 75%, 1)", "rgb(223, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 87.5%)", "rgb(239, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 87.5%, 0)", "rgba(239, 239, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 87.5%, 0.2)", "rgba(239, 239, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 87.5%, 1)", "rgb(239, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 12.5%)", "rgb(52, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 12.5%, 0)", "rgba(52, 52, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 12.5%, 0.2)", "rgba(52, 52, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 12.5%, 1)", "rgb(52, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 25%)", "rgb(104, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 25%, 0)", "rgba(104, 104, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 25%, 0.2)", "rgba(104, 104, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 25%, 1)", "rgb(104, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 37.5%)", "rgb(155, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 37.5%, 0)", "rgba(155, 155, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 37.5%, 0.2)", "rgba(155, 155, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 37.5%, 1)", "rgb(155, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 50%)", "rgb(207, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 50%, 0)", "rgba(207, 207, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 50%, 0.2)", "rgba(207, 207, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 50%, 1)", "rgb(207, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 62.5%)", "rgb(219, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 62.5%, 0)", "rgba(219, 219, 100, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 62.5%, 0.2)", "rgba(219, 219, 100, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 62.5%, 1)", "rgb(219, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 75%)", "rgb(231, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 75%, 0)", "rgba(231, 231, 151, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 75%, 0.2)", "rgba(231, 231, 151, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 75%, 1)", "rgb(231, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 87.5%)", "rgb(243, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 87.5%, 0)", "rgba(243, 243, 203, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 87.5%, 0.2)", "rgba(243, 243, 203, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 87.5%, 1)", "rgb(243, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 12.5%)", "rgb(56, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 12.5%, 0)", "rgba(56, 56, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 12.5%, 0.2)", "rgba(56, 56, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 12.5%, 1)", "rgb(56, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 25%)", "rgb(112, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 25%, 0)", "rgba(112, 112, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 25%, 0.2)", "rgba(112, 112, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 25%, 1)", "rgb(112, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 37.5%)", "rgb(167, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 37.5%, 0)", "rgba(167, 167, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 37.5%, 0.2)", "rgba(167, 167, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 37.5%, 1)", "rgb(167, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 50%)", "rgb(223, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 50%, 0)", "rgba(223, 223, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 50%, 0.2)", "rgba(223, 223, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 50%, 1)", "rgb(223, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 62.5%)", "rgb(231, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 62.5%, 0)", "rgba(231, 231, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 62.5%, 0.2)", "rgba(231, 231, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 62.5%, 1)", "rgb(231, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 75%)", "rgb(239, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 75%, 0)", "rgba(239, 239, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 75%, 0.2)", "rgba(239, 239, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 75%, 1)", "rgb(239, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 87.5%)", "rgb(247, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 87.5%, 0)", "rgba(247, 247, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 87.5%, 0.2)", "rgba(247, 247, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 87.5%, 1)", "rgb(247, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 12.5%)", "rgb(60, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 12.5%, 0)", "rgba(60, 60, 4, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 12.5%, 0.2)", "rgba(60, 60, 4, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 12.5%, 1)", "rgb(60, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 25%)", "rgb(120, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 25%, 0)", "rgba(120, 120, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 25%, 0.2)", "rgba(120, 120, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 25%, 1)", "rgb(120, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 37.5%)", "rgb(179, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 37.5%, 0)", "rgba(179, 179, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 37.5%, 0.2)", "rgba(179, 179, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 37.5%, 1)", "rgb(179, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 50%)", "rgb(239, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 50%, 0)", "rgba(239, 239, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 50%, 0.2)", "rgba(239, 239, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 50%, 1)", "rgb(239, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 62.5%)", "rgb(243, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 62.5%, 0)", "rgba(243, 243, 76, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 62.5%, 0.2)", "rgba(243, 243, 76, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 62.5%, 1)", "rgb(243, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 75%)", "rgb(247, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 75%, 0)", "rgba(247, 247, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 75%, 0.2)", "rgba(247, 247, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 75%, 1)", "rgb(247, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 87.5%)", "rgb(251, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 87.5%, 0)", "rgba(251, 251, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 87.5%, 0.2)", "rgba(251, 251, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 87.5%, 1)", "rgb(251, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 12.5%)", "rgb(64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 12.5%, 0)", "rgba(64, 64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 12.5%, 0.2)", "rgba(64, 64, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 12.5%, 1)", "rgb(64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 25%)", "rgb(128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 25%, 0)", "rgba(128, 128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 25%, 0.2)", "rgba(128, 128, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 25%, 1)", "rgb(128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 37.5%)", "rgb(191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 37.5%, 0)", "rgba(191, 191, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 37.5%, 0.2)", "rgba(191, 191, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 37.5%, 1)", "rgb(191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 50%)", "rgb(255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 50%, 0)", "rgba(255, 255, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 50%, 0.2)", "rgba(255, 255, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 50%, 1)", "rgb(255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 62.5%)", "rgb(255, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 62.5%, 0)", "rgba(255, 255, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 62.5%, 0.2)", "rgba(255, 255, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 62.5%, 1)", "rgb(255, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 75%)", "rgb(255, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 75%, 0)", "rgba(255, 255, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 75%, 0.2)", "rgba(255, 255, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 75%, 1)", "rgb(255, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 87.5%)", "rgb(255, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 87.5%, 0)", "rgba(255, 255, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 87.5%, 0.2)", "rgba(255, 255, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 87.5%, 1)", "rgb(255, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(60, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(60, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 12.5%)", "rgb(32, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 12.5%, 0)", "rgba(32, 36, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 12.5%, 0.2)", "rgba(32, 36, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 12.5%, 1)", "rgb(32, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 25%)", "rgb(64, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 25%, 0)", "rgba(64, 72, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 25%, 0.2)", "rgba(64, 72, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 25%, 1)", "rgb(64, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 37.5%)", "rgb(96, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 37.5%, 0)", "rgba(96, 108, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 37.5%, 0.2)", "rgba(96, 108, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 37.5%, 1)", "rgb(96, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 50%)", "rgb(128, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 50%, 0)", "rgba(128, 143, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 50%, 0.2)", "rgba(128, 143, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 50%, 1)", "rgb(128, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 62.5%)", "rgb(159, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 62.5%, 0)", "rgba(159, 171, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 62.5%, 0.2)", "rgba(159, 171, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 62.5%, 1)", "rgb(159, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 75%)", "rgb(191, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 75%, 0)", "rgba(191, 199, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 75%, 0.2)", "rgba(191, 199, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 75%, 1)", "rgb(191, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 87.5%)", "rgb(223, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 87.5%, 0)", "rgba(223, 227, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 87.5%, 0.2)", "rgba(223, 227, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 87.5%, 1)", "rgb(223, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 12.5%)", "rgb(32, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 12.5%, 0)", "rgba(32, 40, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 12.5%, 0.2)", "rgba(32, 40, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 12.5%, 1)", "rgb(32, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 25%)", "rgb(64, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 25%, 0)", "rgba(64, 80, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 25%, 0.2)", "rgba(64, 80, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 25%, 1)", "rgb(64, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 37.5%)", "rgb(96, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 37.5%, 0)", "rgba(96, 120, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 37.5%, 0.2)", "rgba(96, 120, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 37.5%, 1)", "rgb(96, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 50%)", "rgb(128, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 50%, 0)", "rgba(128, 159, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 50%, 0.2)", "rgba(128, 159, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 50%, 1)", "rgb(128, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 62.5%)", "rgb(159, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 62.5%, 0)", "rgba(159, 183, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 62.5%, 0.2)", "rgba(159, 183, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 62.5%, 1)", "rgb(159, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 75%)", "rgb(191, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 75%, 0)", "rgba(191, 207, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 75%, 0.2)", "rgba(191, 207, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 75%, 1)", "rgb(191, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 87.5%)", "rgb(223, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 87.5%, 0)", "rgba(223, 231, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 87.5%, 0.2)", "rgba(223, 231, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 87.5%, 1)", "rgb(223, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 12.5%)", "rgb(32, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 12.5%, 0)", "rgba(32, 44, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 12.5%, 0.2)", "rgba(32, 44, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 12.5%, 1)", "rgb(32, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 25%)", "rgb(64, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 25%, 0)", "rgba(64, 88, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 25%, 0.2)", "rgba(64, 88, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 25%, 1)", "rgb(64, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 37.5%)", "rgb(96, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 37.5%, 0)", "rgba(96, 131, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 37.5%, 0.2)", "rgba(96, 131, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 37.5%, 1)", "rgb(96, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 50%)", "rgb(128, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 50%, 0)", "rgba(128, 175, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 50%, 0.2)", "rgba(128, 175, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 50%, 1)", "rgb(128, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 62.5%)", "rgb(159, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 62.5%, 0)", "rgba(159, 195, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 62.5%, 0.2)", "rgba(159, 195, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 62.5%, 1)", "rgb(159, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 75%)", "rgb(191, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 75%, 0)", "rgba(191, 215, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 75%, 0.2)", "rgba(191, 215, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 75%, 1)", "rgb(191, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 87.5%)", "rgb(223, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 87.5%, 0)", "rgba(223, 235, 211, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 87.5%, 0.2)", "rgba(223, 235, 211, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 87.5%, 1)", "rgb(223, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 12.5%)", "rgb(32, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 12.5%, 0)", "rgba(32, 48, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 12.5%, 0.2)", "rgba(32, 48, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 12.5%, 1)", "rgb(32, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 25%)", "rgb(64, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 25%, 0)", "rgba(64, 96, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 25%, 0.2)", "rgba(64, 96, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 25%, 1)", "rgb(64, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 37.5%)", "rgb(96, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 37.5%, 0)", "rgba(96, 143, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 37.5%, 0.2)", "rgba(96, 143, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 37.5%, 1)", "rgb(96, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 50%)", "rgb(128, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 50%, 0)", "rgba(128, 191, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 50%, 0.2)", "rgba(128, 191, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 50%, 1)", "rgb(128, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 62.5%)", "rgb(159, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 62.5%, 0)", "rgba(159, 207, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 62.5%, 0.2)", "rgba(159, 207, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 62.5%, 1)", "rgb(159, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 75%)", "rgb(191, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 75%, 0)", "rgba(191, 223, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 75%, 0.2)", "rgba(191, 223, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 75%, 1)", "rgb(191, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 87.5%)", "rgb(223, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 87.5%, 0)", "rgba(223, 239, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 87.5%, 0.2)", "rgba(223, 239, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 87.5%, 1)", "rgb(223, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 12.5%)", "rgb(32, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 12.5%, 0)", "rgba(32, 52, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 12.5%, 0.2)", "rgba(32, 52, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 12.5%, 1)", "rgb(32, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 25%)", "rgb(64, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 25%, 0)", "rgba(64, 104, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 25%, 0.2)", "rgba(64, 104, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 25%, 1)", "rgb(64, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 37.5%)", "rgb(96, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 37.5%, 0)", "rgba(96, 155, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 37.5%, 0.2)", "rgba(96, 155, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 37.5%, 1)", "rgb(96, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 50%)", "rgb(128, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 50%, 0)", "rgba(128, 207, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 50%, 0.2)", "rgba(128, 207, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 50%, 1)", "rgb(128, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 62.5%)", "rgb(159, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 62.5%, 0)", "rgba(159, 219, 100, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 62.5%, 0.2)", "rgba(159, 219, 100, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 62.5%, 1)", "rgb(159, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 75%)", "rgb(191, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 75%, 0)", "rgba(191, 231, 151, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 75%, 0.2)", "rgba(191, 231, 151, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 75%, 1)", "rgb(191, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 87.5%)", "rgb(223, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 87.5%, 0)", "rgba(223, 243, 203, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 87.5%, 0.2)", "rgba(223, 243, 203, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 87.5%, 1)", "rgb(223, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 12.5%)", "rgb(32, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 12.5%, 0)", "rgba(32, 56, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 12.5%, 0.2)", "rgba(32, 56, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 12.5%, 1)", "rgb(32, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 25%)", "rgb(64, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 25%, 0)", "rgba(64, 112, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 25%, 0.2)", "rgba(64, 112, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 25%, 1)", "rgb(64, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 37.5%)", "rgb(96, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 37.5%, 0)", "rgba(96, 167, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 37.5%, 0.2)", "rgba(96, 167, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 37.5%, 1)", "rgb(96, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 50%)", "rgb(128, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 50%, 0)", "rgba(128, 223, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 50%, 0.2)", "rgba(128, 223, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 50%, 1)", "rgb(128, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 62.5%)", "rgb(159, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 62.5%, 0)", "rgba(159, 231, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 62.5%, 0.2)", "rgba(159, 231, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 62.5%, 1)", "rgb(159, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 75%)", "rgb(191, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 75%, 0)", "rgba(191, 239, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 75%, 0.2)", "rgba(191, 239, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 75%, 1)", "rgb(191, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 87.5%)", "rgb(223, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 87.5%, 0)", "rgba(223, 247, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 87.5%, 0.2)", "rgba(223, 247, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 87.5%, 1)", "rgb(223, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 12.5%)", "rgb(32, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 12.5%, 0)", "rgba(32, 60, 4, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 12.5%, 0.2)", "rgba(32, 60, 4, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 12.5%, 1)", "rgb(32, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 25%)", "rgb(64, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 25%, 0)", "rgba(64, 120, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 25%, 0.2)", "rgba(64, 120, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 25%, 1)", "rgb(64, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 37.5%)", "rgb(96, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 37.5%, 0)", "rgba(96, 179, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 37.5%, 0.2)", "rgba(96, 179, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 37.5%, 1)", "rgb(96, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 50%)", "rgb(128, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 50%, 0)", "rgba(128, 239, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 50%, 0.2)", "rgba(128, 239, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 50%, 1)", "rgb(128, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 62.5%)", "rgb(159, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 62.5%, 0)", "rgba(159, 243, 76, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 62.5%, 0.2)", "rgba(159, 243, 76, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 62.5%, 1)", "rgb(159, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 75%)", "rgb(191, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 75%, 0)", "rgba(191, 247, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 75%, 0.2)", "rgba(191, 247, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 75%, 1)", "rgb(191, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 87.5%)", "rgb(223, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 87.5%, 0)", "rgba(223, 251, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 87.5%, 0.2)", "rgba(223, 251, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 87.5%, 1)", "rgb(223, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 12.5%)", "rgb(32, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 12.5%, 0)", "rgba(32, 64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 12.5%, 0.2)", "rgba(32, 64, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 12.5%, 1)", "rgb(32, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 25%)", "rgb(64, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 25%, 0)", "rgba(64, 128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 25%, 0.2)", "rgba(64, 128, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 25%, 1)", "rgb(64, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 37.5%)", "rgb(96, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 37.5%, 0)", "rgba(96, 191, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 37.5%, 0.2)", "rgba(96, 191, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 37.5%, 1)", "rgb(96, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 50%)", "rgb(128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 50%, 0)", "rgba(128, 255, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 50%, 0.2)", "rgba(128, 255, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 50%, 1)", "rgb(128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 62.5%)", "rgb(159, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 62.5%, 0)", "rgba(159, 255, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 62.5%, 0.2)", "rgba(159, 255, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 62.5%, 1)", "rgb(159, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 75%)", "rgb(191, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 75%, 0)", "rgba(191, 255, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 75%, 0.2)", "rgba(191, 255, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 75%, 1)", "rgb(191, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 87.5%)", "rgb(223, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 87.5%, 0)", "rgba(223, 255, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 87.5%, 0.2)", "rgba(223, 255, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 87.5%, 1)", "rgb(223, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(90, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(90, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 12.5%)", "rgb(28, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 12.5%, 0)", "rgba(28, 36, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 12.5%, 0.2)", "rgba(28, 36, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 12.5%, 1)", "rgb(28, 36, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 25%)", "rgb(56, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 25%, 0)", "rgba(56, 72, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 25%, 0.2)", "rgba(56, 72, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 25%, 1)", "rgb(56, 72, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 37.5%)", "rgb(84, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 37.5%, 0)", "rgba(84, 108, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 37.5%, 0.2)", "rgba(84, 108, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 37.5%, 1)", "rgb(84, 108, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 50%)", "rgb(112, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 50%, 0)", "rgba(112, 143, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 50%, 0.2)", "rgba(112, 143, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 50%, 1)", "rgb(112, 143, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 62.5%)", "rgb(147, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 62.5%, 0)", "rgba(147, 171, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 62.5%, 0.2)", "rgba(147, 171, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 62.5%, 1)", "rgb(147, 171, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 75%)", "rgb(183, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 75%, 0)", "rgba(183, 199, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 75%, 0.2)", "rgba(183, 199, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 75%, 1)", "rgb(183, 199, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 87.5%)", "rgb(219, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 87.5%, 0)", "rgba(219, 227, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 87.5%, 0.2)", "rgba(219, 227, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 87.5%, 1)", "rgb(219, 227, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 12.5%)", "rgb(24, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 12.5%, 0)", "rgba(24, 40, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 12.5%, 0.2)", "rgba(24, 40, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 12.5%, 1)", "rgb(24, 40, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 25%)", "rgb(48, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 25%, 0)", "rgba(48, 80, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 25%, 0.2)", "rgba(48, 80, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 25%, 1)", "rgb(48, 80, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 37.5%)", "rgb(72, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 37.5%, 0)", "rgba(72, 120, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 37.5%, 0.2)", "rgba(72, 120, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 37.5%, 1)", "rgb(72, 120, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 50%)", "rgb(96, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 50%, 0)", "rgba(96, 159, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 50%, 0.2)", "rgba(96, 159, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 50%, 1)", "rgb(96, 159, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 62.5%)", "rgb(135, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 62.5%, 0)", "rgba(135, 183, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 62.5%, 0.2)", "rgba(135, 183, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 62.5%, 1)", "rgb(135, 183, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 75%)", "rgb(175, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 75%, 0)", "rgba(175, 207, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 75%, 0.2)", "rgba(175, 207, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 75%, 1)", "rgb(175, 207, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 87.5%)", "rgb(215, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 87.5%, 0)", "rgba(215, 231, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 87.5%, 0.2)", "rgba(215, 231, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 87.5%, 1)", "rgb(215, 231, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 12.5%)", "rgb(20, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 12.5%, 0)", "rgba(20, 44, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 12.5%, 0.2)", "rgba(20, 44, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 12.5%, 1)", "rgb(20, 44, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 25%)", "rgb(40, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 25%, 0)", "rgba(40, 88, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 25%, 0.2)", "rgba(40, 88, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 25%, 1)", "rgb(40, 88, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 37.5%)", "rgb(60, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 37.5%, 0)", "rgba(60, 131, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 37.5%, 0.2)", "rgba(60, 131, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 37.5%, 1)", "rgb(60, 131, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 50%)", "rgb(80, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 50%, 0)", "rgba(80, 175, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 50%, 0.2)", "rgba(80, 175, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 50%, 1)", "rgb(80, 175, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 62.5%)", "rgb(124, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 62.5%, 0)", "rgba(124, 195, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 62.5%, 0.2)", "rgba(124, 195, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 62.5%, 1)", "rgb(124, 195, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 75%)", "rgb(167, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 75%, 0)", "rgba(167, 215, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 75%, 0.2)", "rgba(167, 215, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 75%, 1)", "rgb(167, 215, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 87.5%)", "rgb(211, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 87.5%, 0)", "rgba(211, 235, 211, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 87.5%, 0.2)", "rgba(211, 235, 211, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 87.5%, 1)", "rgb(211, 235, 211)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 12.5%)", "rgb(16, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 12.5%, 0)", "rgba(16, 48, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 12.5%, 0.2)", "rgba(16, 48, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 12.5%, 1)", "rgb(16, 48, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 25%)", "rgb(32, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 25%, 0)", "rgba(32, 96, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 25%, 0.2)", "rgba(32, 96, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 25%, 1)", "rgb(32, 96, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 37.5%)", "rgb(48, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 37.5%, 0)", "rgba(48, 143, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 37.5%, 0.2)", "rgba(48, 143, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 37.5%, 1)", "rgb(48, 143, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 50%)", "rgb(64, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 50%, 0)", "rgba(64, 191, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 50%, 0.2)", "rgba(64, 191, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 50%, 1)", "rgb(64, 191, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 62.5%)", "rgb(112, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 62.5%, 0)", "rgba(112, 207, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 62.5%, 0.2)", "rgba(112, 207, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 62.5%, 1)", "rgb(112, 207, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 75%)", "rgb(159, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 75%, 0)", "rgba(159, 223, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 75%, 0.2)", "rgba(159, 223, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 75%, 1)", "rgb(159, 223, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 87.5%)", "rgb(207, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 87.5%, 0)", "rgba(207, 239, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 87.5%, 0.2)", "rgba(207, 239, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 87.5%, 1)", "rgb(207, 239, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 12.5%)", "rgb(12, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 12.5%, 0)", "rgba(12, 52, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 12.5%, 0.2)", "rgba(12, 52, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 12.5%, 1)", "rgb(12, 52, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 25%)", "rgb(24, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 25%, 0)", "rgba(24, 104, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 25%, 0.2)", "rgba(24, 104, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 25%, 1)", "rgb(24, 104, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 37.5%)", "rgb(36, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 37.5%, 0)", "rgba(36, 155, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 37.5%, 0.2)", "rgba(36, 155, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 37.5%, 1)", "rgb(36, 155, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 50%)", "rgb(48, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 50%, 0)", "rgba(48, 207, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 50%, 0.2)", "rgba(48, 207, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 50%, 1)", "rgb(48, 207, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 62.5%)", "rgb(100, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 62.5%, 0)", "rgba(100, 219, 100, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 62.5%, 0.2)", "rgba(100, 219, 100, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 62.5%, 1)", "rgb(100, 219, 100)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 75%)", "rgb(151, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 75%, 0)", "rgba(151, 231, 151, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 75%, 0.2)", "rgba(151, 231, 151, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 75%, 1)", "rgb(151, 231, 151)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 87.5%)", "rgb(203, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 87.5%, 0)", "rgba(203, 243, 203, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 87.5%, 0.2)", "rgba(203, 243, 203, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 87.5%, 1)", "rgb(203, 243, 203)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 12.5%)", "rgb(8, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 12.5%, 0)", "rgba(8, 56, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 12.5%, 0.2)", "rgba(8, 56, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 12.5%, 1)", "rgb(8, 56, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 25%)", "rgb(16, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 25%, 0)", "rgba(16, 112, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 25%, 0.2)", "rgba(16, 112, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 25%, 1)", "rgb(16, 112, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 37.5%)", "rgb(24, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 37.5%, 0)", "rgba(24, 167, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 37.5%, 0.2)", "rgba(24, 167, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 37.5%, 1)", "rgb(24, 167, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 50%)", "rgb(32, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 50%, 0)", "rgba(32, 223, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 50%, 0.2)", "rgba(32, 223, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 50%, 1)", "rgb(32, 223, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 62.5%)", "rgb(88, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 62.5%, 0)", "rgba(88, 231, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 62.5%, 0.2)", "rgba(88, 231, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 62.5%, 1)", "rgb(88, 231, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 75%)", "rgb(143, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 75%, 0)", "rgba(143, 239, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 75%, 0.2)", "rgba(143, 239, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 75%, 1)", "rgb(143, 239, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 87.5%)", "rgb(199, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 87.5%, 0)", "rgba(199, 247, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 87.5%, 0.2)", "rgba(199, 247, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 87.5%, 1)", "rgb(199, 247, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 12.5%)", "rgb(4, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 12.5%, 0)", "rgba(4, 60, 4, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 12.5%, 0.2)", "rgba(4, 60, 4, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 12.5%, 1)", "rgb(4, 60, 4)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 25%)", "rgb(8, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 25%, 0)", "rgba(8, 120, 8, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 25%, 0.2)", "rgba(8, 120, 8, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 25%, 1)", "rgb(8, 120, 8)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 37.5%)", "rgb(12, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 37.5%, 0)", "rgba(12, 179, 12, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 37.5%, 0.2)", "rgba(12, 179, 12, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 37.5%, 1)", "rgb(12, 179, 12)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 50%)", "rgb(16, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 50%, 0)", "rgba(16, 239, 16, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 50%, 0.2)", "rgba(16, 239, 16, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 50%, 1)", "rgb(16, 239, 16)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 62.5%)", "rgb(76, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 62.5%, 0)", "rgba(76, 243, 76, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 62.5%, 0.2)", "rgba(76, 243, 76, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 62.5%, 1)", "rgb(76, 243, 76)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 75%)", "rgb(135, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 75%, 0)", "rgba(135, 247, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 75%, 0.2)", "rgba(135, 247, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 75%, 1)", "rgb(135, 247, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 87.5%)", "rgb(195, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 87.5%, 0)", "rgba(195, 251, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 87.5%, 0.2)", "rgba(195, 251, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 87.5%, 1)", "rgb(195, 251, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 12.5%)", "rgb(0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 12.5%, 0)", "rgba(0, 64, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 12.5%, 0.2)", "rgba(0, 64, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 12.5%, 1)", "rgb(0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 25%)", "rgb(0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 25%, 0)", "rgba(0, 128, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 25%, 0.2)", "rgba(0, 128, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 25%, 1)", "rgb(0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 37.5%)", "rgb(0, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 37.5%, 0)", "rgba(0, 191, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 37.5%, 0.2)", "rgba(0, 191, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 37.5%, 1)", "rgb(0, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 50%)", "rgb(0, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 50%, 0)", "rgba(0, 255, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 50%, 0.2)", "rgba(0, 255, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 50%, 1)", "rgb(0, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 62.5%)", "rgb(64, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 62.5%, 0)", "rgba(64, 255, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 62.5%, 0.2)", "rgba(64, 255, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 62.5%, 1)", "rgb(64, 255, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 75%)", "rgb(128, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 75%, 0)", "rgba(128, 255, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 75%, 0.2)", "rgba(128, 255, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 75%, 1)", "rgb(128, 255, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 87.5%)", "rgb(191, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 87.5%, 0)", "rgba(191, 255, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 87.5%, 0.2)", "rgba(191, 255, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 87.5%, 1)", "rgb(191, 255, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(120, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(120, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 12.5%)", "rgb(28, 36, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 12.5%, 0)", "rgba(28, 36, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 12.5%, 0.2)", "rgba(28, 36, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 12.5%, 1)", "rgb(28, 36, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 25%)", "rgb(56, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 25%, 0)", "rgba(56, 72, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 25%, 0.2)", "rgba(56, 72, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 25%, 1)", "rgb(56, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 37.5%)", "rgb(84, 108, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 37.5%, 0)", "rgba(84, 108, 108, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 37.5%, 0.2)", "rgba(84, 108, 108, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 37.5%, 1)", "rgb(84, 108, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 50%)", "rgb(112, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 50%, 0)", "rgba(112, 143, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 50%, 0.2)", "rgba(112, 143, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 50%, 1)", "rgb(112, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 62.5%)", "rgb(147, 171, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 62.5%, 0)", "rgba(147, 171, 171, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 62.5%, 0.2)", "rgba(147, 171, 171, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 62.5%, 1)", "rgb(147, 171, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 75%)", "rgb(183, 199, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 75%, 0)", "rgba(183, 199, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 75%, 0.2)", "rgba(183, 199, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 75%, 1)", "rgb(183, 199, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 87.5%)", "rgb(219, 227, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 87.5%, 0)", "rgba(219, 227, 227, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 87.5%, 0.2)", "rgba(219, 227, 227, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 87.5%, 1)", "rgb(219, 227, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 12.5%)", "rgb(24, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 12.5%, 0)", "rgba(24, 40, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 12.5%, 0.2)", "rgba(24, 40, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 12.5%, 1)", "rgb(24, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 25%)", "rgb(48, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 25%, 0)", "rgba(48, 80, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 25%, 0.2)", "rgba(48, 80, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 25%, 1)", "rgb(48, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 37.5%)", "rgb(72, 120, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 37.5%, 0)", "rgba(72, 120, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 37.5%, 0.2)", "rgba(72, 120, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 37.5%, 1)", "rgb(72, 120, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 50%)", "rgb(96, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 50%, 0)", "rgba(96, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 50%, 0.2)", "rgba(96, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 50%, 1)", "rgb(96, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 62.5%)", "rgb(135, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 62.5%, 0)", "rgba(135, 183, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 62.5%, 0.2)", "rgba(135, 183, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 62.5%, 1)", "rgb(135, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 75%)", "rgb(175, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 75%, 0)", "rgba(175, 207, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 75%, 0.2)", "rgba(175, 207, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 75%, 1)", "rgb(175, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 87.5%)", "rgb(215, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 87.5%, 0)", "rgba(215, 231, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 87.5%, 0.2)", "rgba(215, 231, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 87.5%, 1)", "rgb(215, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 12.5%)", "rgb(20, 44, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 12.5%, 0)", "rgba(20, 44, 44, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 12.5%, 0.2)", "rgba(20, 44, 44, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 12.5%, 1)", "rgb(20, 44, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 25%)", "rgb(40, 88, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 25%, 0)", "rgba(40, 88, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 25%, 0.2)", "rgba(40, 88, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 25%, 1)", "rgb(40, 88, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 37.5%)", "rgb(60, 131, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 37.5%, 0)", "rgba(60, 131, 131, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 37.5%, 0.2)", "rgba(60, 131, 131, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 37.5%, 1)", "rgb(60, 131, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 50%)", "rgb(80, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 50%, 0)", "rgba(80, 175, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 50%, 0.2)", "rgba(80, 175, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 50%, 1)", "rgb(80, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 62.5%)", "rgb(124, 195, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 62.5%, 0)", "rgba(124, 195, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 62.5%, 0.2)", "rgba(124, 195, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 62.5%, 1)", "rgb(124, 195, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 75%)", "rgb(167, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 75%, 0)", "rgba(167, 215, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 75%, 0.2)", "rgba(167, 215, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 75%, 1)", "rgb(167, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 87.5%)", "rgb(211, 235, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 87.5%, 0)", "rgba(211, 235, 235, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 87.5%, 0.2)", "rgba(211, 235, 235, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 87.5%, 1)", "rgb(211, 235, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 12.5%)", "rgb(16, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 12.5%, 0)", "rgba(16, 48, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 12.5%, 0.2)", "rgba(16, 48, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 12.5%, 1)", "rgb(16, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 25%)", "rgb(32, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 25%, 0)", "rgba(32, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 25%, 0.2)", "rgba(32, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 25%, 1)", "rgb(32, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 37.5%)", "rgb(48, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 37.5%, 0)", "rgba(48, 143, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 37.5%, 0.2)", "rgba(48, 143, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 37.5%, 1)", "rgb(48, 143, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 50%)", "rgb(64, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 50%, 0)", "rgba(64, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 50%, 0.2)", "rgba(64, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 50%, 1)", "rgb(64, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 62.5%)", "rgb(112, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 62.5%, 0)", "rgba(112, 207, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 62.5%, 0.2)", "rgba(112, 207, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 62.5%, 1)", "rgb(112, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 75%)", "rgb(159, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 75%, 0)", "rgba(159, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 75%, 0.2)", "rgba(159, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 75%, 1)", "rgb(159, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 87.5%)", "rgb(207, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 87.5%, 0)", "rgba(207, 239, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 87.5%, 0.2)", "rgba(207, 239, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 87.5%, 1)", "rgb(207, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 12.5%)", "rgb(12, 52, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 12.5%, 0)", "rgba(12, 52, 52, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 12.5%, 0.2)", "rgba(12, 52, 52, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 12.5%, 1)", "rgb(12, 52, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 25%)", "rgb(24, 104, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 25%, 0)", "rgba(24, 104, 104, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 25%, 0.2)", "rgba(24, 104, 104, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 25%, 1)", "rgb(24, 104, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 37.5%)", "rgb(36, 155, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 37.5%, 0)", "rgba(36, 155, 155, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 37.5%, 0.2)", "rgba(36, 155, 155, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 37.5%, 1)", "rgb(36, 155, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 50%)", "rgb(48, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 50%, 0)", "rgba(48, 207, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 50%, 0.2)", "rgba(48, 207, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 50%, 1)", "rgb(48, 207, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 62.5%)", "rgb(100, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 62.5%, 0)", "rgba(100, 219, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 62.5%, 0.2)", "rgba(100, 219, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 62.5%, 1)", "rgb(100, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 75%)", "rgb(151, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 75%, 0)", "rgba(151, 231, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 75%, 0.2)", "rgba(151, 231, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 75%, 1)", "rgb(151, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 87.5%)", "rgb(203, 243, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 87.5%, 0)", "rgba(203, 243, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 87.5%, 0.2)", "rgba(203, 243, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 87.5%, 1)", "rgb(203, 243, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 12.5%)", "rgb(8, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 12.5%, 0)", "rgba(8, 56, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 12.5%, 0.2)", "rgba(8, 56, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 12.5%, 1)", "rgb(8, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 25%)", "rgb(16, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 25%, 0)", "rgba(16, 112, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 25%, 0.2)", "rgba(16, 112, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 25%, 1)", "rgb(16, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 37.5%)", "rgb(24, 167, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 37.5%, 0)", "rgba(24, 167, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 37.5%, 0.2)", "rgba(24, 167, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 37.5%, 1)", "rgb(24, 167, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 50%)", "rgb(32, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 50%, 0)", "rgba(32, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 50%, 0.2)", "rgba(32, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 50%, 1)", "rgb(32, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 62.5%)", "rgb(88, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 62.5%, 0)", "rgba(88, 231, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 62.5%, 0.2)", "rgba(88, 231, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 62.5%, 1)", "rgb(88, 231, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 75%)", "rgb(143, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 75%, 0)", "rgba(143, 239, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 75%, 0.2)", "rgba(143, 239, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 75%, 1)", "rgb(143, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 87.5%)", "rgb(199, 247, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 87.5%, 0)", "rgba(199, 247, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 87.5%, 0.2)", "rgba(199, 247, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 87.5%, 1)", "rgb(199, 247, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 12.5%)", "rgb(4, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 12.5%, 0)", "rgba(4, 60, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 12.5%, 0.2)", "rgba(4, 60, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 12.5%, 1)", "rgb(4, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 25%)", "rgb(8, 120, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 25%, 0)", "rgba(8, 120, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 25%, 0.2)", "rgba(8, 120, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 25%, 1)", "rgb(8, 120, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 37.5%)", "rgb(12, 179, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 37.5%, 0)", "rgba(12, 179, 179, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 37.5%, 0.2)", "rgba(12, 179, 179, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 37.5%, 1)", "rgb(12, 179, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 50%)", "rgb(16, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 50%, 0)", "rgba(16, 239, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 50%, 0.2)", "rgba(16, 239, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 50%, 1)", "rgb(16, 239, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 62.5%)", "rgb(76, 243, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 62.5%, 0)", "rgba(76, 243, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 62.5%, 0.2)", "rgba(76, 243, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 62.5%, 1)", "rgb(76, 243, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 75%)", "rgb(135, 247, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 75%, 0)", "rgba(135, 247, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 75%, 0.2)", "rgba(135, 247, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 75%, 1)", "rgb(135, 247, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 87.5%)", "rgb(195, 251, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 87.5%, 0)", "rgba(195, 251, 251, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 87.5%, 0.2)", "rgba(195, 251, 251, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 87.5%, 1)", "rgb(195, 251, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 12.5%)", "rgb(0, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 12.5%, 0)", "rgba(0, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 12.5%, 0.2)", "rgba(0, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 12.5%, 1)", "rgb(0, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 25%)", "rgb(0, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 25%, 0)", "rgba(0, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 25%, 0.2)", "rgba(0, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 25%, 1)", "rgb(0, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 37.5%)", "rgb(0, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 37.5%, 0)", "rgba(0, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 37.5%, 0.2)", "rgba(0, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 37.5%, 1)", "rgb(0, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 50%)", "rgb(0, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 50%, 0)", "rgba(0, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 50%, 0.2)", "rgba(0, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 50%, 1)", "rgb(0, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 62.5%)", "rgb(64, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 62.5%, 0)", "rgba(64, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 62.5%, 0.2)", "rgba(64, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 62.5%, 1)", "rgb(64, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 75%)", "rgb(128, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 75%, 0)", "rgba(128, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 75%, 0.2)", "rgba(128, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 75%, 1)", "rgb(128, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 87.5%)", "rgb(191, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 87.5%, 0)", "rgba(191, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 87.5%, 0.2)", "rgba(191, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 87.5%, 1)", "rgb(191, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(180, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(180, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 12.5%)", "rgb(28, 32, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 12.5%, 0)", "rgba(28, 32, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 12.5%, 0.2)", "rgba(28, 32, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 12.5%, 1)", "rgb(28, 32, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 25%)", "rgb(56, 64, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 25%, 0)", "rgba(56, 64, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 25%, 0.2)", "rgba(56, 64, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 25%, 1)", "rgb(56, 64, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 37.5%)", "rgb(84, 96, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 37.5%, 0)", "rgba(84, 96, 108, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 37.5%, 0.2)", "rgba(84, 96, 108, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 37.5%, 1)", "rgb(84, 96, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 50%)", "rgb(112, 128, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 50%, 0)", "rgba(112, 128, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 50%, 0.2)", "rgba(112, 128, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 50%, 1)", "rgb(112, 128, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 62.5%)", "rgb(147, 159, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 62.5%, 0)", "rgba(147, 159, 171, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 62.5%, 0.2)", "rgba(147, 159, 171, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 62.5%, 1)", "rgb(147, 159, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 75%)", "rgb(183, 191, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 75%, 0)", "rgba(183, 191, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 75%, 0.2)", "rgba(183, 191, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 75%, 1)", "rgb(183, 191, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 87.5%)", "rgb(219, 223, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 87.5%, 0)", "rgba(219, 223, 227, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 87.5%, 0.2)", "rgba(219, 223, 227, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 87.5%, 1)", "rgb(219, 223, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 12.5%)", "rgb(24, 32, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 12.5%, 0)", "rgba(24, 32, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 12.5%, 0.2)", "rgba(24, 32, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 12.5%, 1)", "rgb(24, 32, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 25%)", "rgb(48, 64, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 25%, 0)", "rgba(48, 64, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 25%, 0.2)", "rgba(48, 64, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 25%, 1)", "rgb(48, 64, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 37.5%)", "rgb(72, 96, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 37.5%, 0)", "rgba(72, 96, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 37.5%, 0.2)", "rgba(72, 96, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 37.5%, 1)", "rgb(72, 96, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 50%)", "rgb(96, 128, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 50%, 0)", "rgba(96, 128, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 50%, 0.2)", "rgba(96, 128, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 50%, 1)", "rgb(96, 128, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 62.5%)", "rgb(135, 159, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 62.5%, 0)", "rgba(135, 159, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 62.5%, 0.2)", "rgba(135, 159, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 62.5%, 1)", "rgb(135, 159, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 75%)", "rgb(175, 191, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 75%, 0)", "rgba(175, 191, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 75%, 0.2)", "rgba(175, 191, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 75%, 1)", "rgb(175, 191, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 87.5%)", "rgb(215, 223, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 87.5%, 0)", "rgba(215, 223, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 87.5%, 0.2)", "rgba(215, 223, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 87.5%, 1)", "rgb(215, 223, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 12.5%)", "rgb(20, 32, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 12.5%, 0)", "rgba(20, 32, 44, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 12.5%, 0.2)", "rgba(20, 32, 44, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 12.5%, 1)", "rgb(20, 32, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 25%)", "rgb(40, 64, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 25%, 0)", "rgba(40, 64, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 25%, 0.2)", "rgba(40, 64, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 25%, 1)", "rgb(40, 64, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 37.5%)", "rgb(60, 96, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 37.5%, 0)", "rgba(60, 96, 131, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 37.5%, 0.2)", "rgba(60, 96, 131, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 37.5%, 1)", "rgb(60, 96, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 50%)", "rgb(80, 128, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 50%, 0)", "rgba(80, 128, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 50%, 0.2)", "rgba(80, 128, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 50%, 1)", "rgb(80, 128, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 62.5%)", "rgb(124, 159, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 62.5%, 0)", "rgba(124, 159, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 62.5%, 0.2)", "rgba(124, 159, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 62.5%, 1)", "rgb(124, 159, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 75%)", "rgb(167, 191, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 75%, 0)", "rgba(167, 191, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 75%, 0.2)", "rgba(167, 191, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 75%, 1)", "rgb(167, 191, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 87.5%)", "rgb(211, 223, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 87.5%, 0)", "rgba(211, 223, 235, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 87.5%, 0.2)", "rgba(211, 223, 235, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 87.5%, 1)", "rgb(211, 223, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 12.5%)", "rgb(16, 32, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 12.5%, 0)", "rgba(16, 32, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 12.5%, 0.2)", "rgba(16, 32, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 12.5%, 1)", "rgb(16, 32, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 25%)", "rgb(32, 64, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 25%, 0)", "rgba(32, 64, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 25%, 0.2)", "rgba(32, 64, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 25%, 1)", "rgb(32, 64, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 37.5%)", "rgb(48, 96, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 37.5%, 0)", "rgba(48, 96, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 37.5%, 0.2)", "rgba(48, 96, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 37.5%, 1)", "rgb(48, 96, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 50%)", "rgb(64, 128, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 50%, 0)", "rgba(64, 128, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 50%, 0.2)", "rgba(64, 128, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 50%, 1)", "rgb(64, 128, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 62.5%)", "rgb(112, 159, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 62.5%, 0)", "rgba(112, 159, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 62.5%, 0.2)", "rgba(112, 159, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 62.5%, 1)", "rgb(112, 159, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 75%)", "rgb(159, 191, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 75%, 0)", "rgba(159, 191, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 75%, 0.2)", "rgba(159, 191, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 75%, 1)", "rgb(159, 191, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 87.5%)", "rgb(207, 223, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 87.5%, 0)", "rgba(207, 223, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 87.5%, 0.2)", "rgba(207, 223, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 87.5%, 1)", "rgb(207, 223, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 12.5%)", "rgb(12, 32, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 12.5%, 0)", "rgba(12, 32, 52, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 12.5%, 0.2)", "rgba(12, 32, 52, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 12.5%, 1)", "rgb(12, 32, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 25%)", "rgb(24, 64, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 25%, 0)", "rgba(24, 64, 104, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 25%, 0.2)", "rgba(24, 64, 104, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 25%, 1)", "rgb(24, 64, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 37.5%)", "rgb(36, 96, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 37.5%, 0)", "rgba(36, 96, 155, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 37.5%, 0.2)", "rgba(36, 96, 155, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 37.5%, 1)", "rgb(36, 96, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 50%)", "rgb(48, 128, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 50%, 0)", "rgba(48, 128, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 50%, 0.2)", "rgba(48, 128, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 50%, 1)", "rgb(48, 128, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 62.5%)", "rgb(100, 159, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 62.5%, 0)", "rgba(100, 159, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 62.5%, 0.2)", "rgba(100, 159, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 62.5%, 1)", "rgb(100, 159, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 75%)", "rgb(151, 191, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 75%, 0)", "rgba(151, 191, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 75%, 0.2)", "rgba(151, 191, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 75%, 1)", "rgb(151, 191, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 87.5%)", "rgb(203, 223, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 87.5%, 0)", "rgba(203, 223, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 87.5%, 0.2)", "rgba(203, 223, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 87.5%, 1)", "rgb(203, 223, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 12.5%)", "rgb(8, 32, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 12.5%, 0)", "rgba(8, 32, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 12.5%, 0.2)", "rgba(8, 32, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 12.5%, 1)", "rgb(8, 32, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 25%)", "rgb(16, 64, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 25%, 0)", "rgba(16, 64, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 25%, 0.2)", "rgba(16, 64, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 25%, 1)", "rgb(16, 64, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 37.5%)", "rgb(24, 96, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 37.5%, 0)", "rgba(24, 96, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 37.5%, 0.2)", "rgba(24, 96, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 37.5%, 1)", "rgb(24, 96, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 50%)", "rgb(32, 128, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 50%, 0)", "rgba(32, 128, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 50%, 0.2)", "rgba(32, 128, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 50%, 1)", "rgb(32, 128, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 62.5%)", "rgb(88, 159, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 62.5%, 0)", "rgba(88, 159, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 62.5%, 0.2)", "rgba(88, 159, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 62.5%, 1)", "rgb(88, 159, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 75%)", "rgb(143, 191, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 75%, 0)", "rgba(143, 191, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 75%, 0.2)", "rgba(143, 191, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 75%, 1)", "rgb(143, 191, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 87.5%)", "rgb(199, 223, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 87.5%, 0)", "rgba(199, 223, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 87.5%, 0.2)", "rgba(199, 223, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 87.5%, 1)", "rgb(199, 223, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 12.5%)", "rgb(4, 32, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 12.5%, 0)", "rgba(4, 32, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 12.5%, 0.2)", "rgba(4, 32, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 12.5%, 1)", "rgb(4, 32, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 25%)", "rgb(8, 64, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 25%, 0)", "rgba(8, 64, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 25%, 0.2)", "rgba(8, 64, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 25%, 1)", "rgb(8, 64, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 37.5%)", "rgb(12, 96, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 37.5%, 0)", "rgba(12, 96, 179, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 37.5%, 0.2)", "rgba(12, 96, 179, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 37.5%, 1)", "rgb(12, 96, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 50%)", "rgb(16, 128, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 50%, 0)", "rgba(16, 128, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 50%, 0.2)", "rgba(16, 128, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 50%, 1)", "rgb(16, 128, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 62.5%)", "rgb(76, 159, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 62.5%, 0)", "rgba(76, 159, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 62.5%, 0.2)", "rgba(76, 159, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 62.5%, 1)", "rgb(76, 159, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 75%)", "rgb(135, 191, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 75%, 0)", "rgba(135, 191, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 75%, 0.2)", "rgba(135, 191, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 75%, 1)", "rgb(135, 191, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 87.5%)", "rgb(195, 223, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 87.5%, 0)", "rgba(195, 223, 251, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 87.5%, 0.2)", "rgba(195, 223, 251, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 87.5%, 1)", "rgb(195, 223, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 12.5%)", "rgb(0, 32, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 12.5%, 0)", "rgba(0, 32, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 12.5%, 0.2)", "rgba(0, 32, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 12.5%, 1)", "rgb(0, 32, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 25%)", "rgb(0, 64, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 25%, 0)", "rgba(0, 64, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 25%, 0.2)", "rgba(0, 64, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 25%, 1)", "rgb(0, 64, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 37.5%)", "rgb(0, 96, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 37.5%, 0)", "rgba(0, 96, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 37.5%, 0.2)", "rgba(0, 96, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 37.5%, 1)", "rgb(0, 96, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 50%)", "rgb(0, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 50%, 0)", "rgba(0, 128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 50%, 0.2)", "rgba(0, 128, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 50%, 1)", "rgb(0, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 62.5%)", "rgb(64, 159, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 62.5%, 0)", "rgba(64, 159, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 62.5%, 0.2)", "rgba(64, 159, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 62.5%, 1)", "rgb(64, 159, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 75%)", "rgb(128, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 75%, 0)", "rgba(128, 191, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 75%, 0.2)", "rgba(128, 191, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 75%, 1)", "rgb(128, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 87.5%)", "rgb(191, 223, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 87.5%, 0)", "rgba(191, 223, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 87.5%, 0.2)", "rgba(191, 223, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 87.5%, 1)", "rgb(191, 223, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(210, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(210, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 12.5%)", "rgb(28, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 12.5%, 0)", "rgba(28, 28, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 12.5%, 0.2)", "rgba(28, 28, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 12.5%, 1)", "rgb(28, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 25%)", "rgb(56, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 25%, 0)", "rgba(56, 56, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 25%, 0.2)", "rgba(56, 56, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 25%, 1)", "rgb(56, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 37.5%)", "rgb(84, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 37.5%, 0)", "rgba(84, 84, 108, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 37.5%, 0.2)", "rgba(84, 84, 108, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 37.5%, 1)", "rgb(84, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 50%)", "rgb(112, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 50%, 0)", "rgba(112, 112, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 50%, 0.2)", "rgba(112, 112, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 50%, 1)", "rgb(112, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 62.5%)", "rgb(147, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 62.5%, 0)", "rgba(147, 147, 171, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 62.5%, 0.2)", "rgba(147, 147, 171, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 62.5%, 1)", "rgb(147, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 75%)", "rgb(183, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 75%, 0)", "rgba(183, 183, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 75%, 0.2)", "rgba(183, 183, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 75%, 1)", "rgb(183, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 87.5%)", "rgb(219, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 87.5%, 0)", "rgba(219, 219, 227, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 87.5%, 0.2)", "rgba(219, 219, 227, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 87.5%, 1)", "rgb(219, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 12.5%)", "rgb(24, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 12.5%, 0)", "rgba(24, 24, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 12.5%, 0.2)", "rgba(24, 24, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 12.5%, 1)", "rgb(24, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 25%)", "rgb(48, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 25%, 0)", "rgba(48, 48, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 25%, 0.2)", "rgba(48, 48, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 25%, 1)", "rgb(48, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 37.5%)", "rgb(72, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 37.5%, 0)", "rgba(72, 72, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 37.5%, 0.2)", "rgba(72, 72, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 37.5%, 1)", "rgb(72, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 50%)", "rgb(96, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 50%, 0)", "rgba(96, 96, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 50%, 0.2)", "rgba(96, 96, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 50%, 1)", "rgb(96, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 62.5%)", "rgb(135, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 62.5%, 0)", "rgba(135, 135, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 62.5%, 0.2)", "rgba(135, 135, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 62.5%, 1)", "rgb(135, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 75%)", "rgb(175, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 75%, 0)", "rgba(175, 175, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 75%, 0.2)", "rgba(175, 175, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 75%, 1)", "rgb(175, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 87.5%)", "rgb(215, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 87.5%, 0)", "rgba(215, 215, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 87.5%, 0.2)", "rgba(215, 215, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 87.5%, 1)", "rgb(215, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 12.5%)", "rgb(20, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 12.5%, 0)", "rgba(20, 20, 44, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 12.5%, 0.2)", "rgba(20, 20, 44, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 12.5%, 1)", "rgb(20, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 25%)", "rgb(40, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 25%, 0)", "rgba(40, 40, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 25%, 0.2)", "rgba(40, 40, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 25%, 1)", "rgb(40, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 37.5%)", "rgb(60, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 37.5%, 0)", "rgba(60, 60, 131, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 37.5%, 0.2)", "rgba(60, 60, 131, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 37.5%, 1)", "rgb(60, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 50%)", "rgb(80, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 50%, 0)", "rgba(80, 80, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 50%, 0.2)", "rgba(80, 80, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 50%, 1)", "rgb(80, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 62.5%)", "rgb(124, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 62.5%, 0)", "rgba(124, 124, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 62.5%, 0.2)", "rgba(124, 124, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 62.5%, 1)", "rgb(124, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 75%)", "rgb(167, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 75%, 0)", "rgba(167, 167, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 75%, 0.2)", "rgba(167, 167, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 75%, 1)", "rgb(167, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 87.5%)", "rgb(211, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 87.5%, 0)", "rgba(211, 211, 235, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 87.5%, 0.2)", "rgba(211, 211, 235, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 87.5%, 1)", "rgb(211, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 12.5%)", "rgb(16, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 12.5%, 0)", "rgba(16, 16, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 12.5%, 0.2)", "rgba(16, 16, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 12.5%, 1)", "rgb(16, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 25%)", "rgb(32, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 25%, 0)", "rgba(32, 32, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 25%, 0.2)", "rgba(32, 32, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 25%, 1)", "rgb(32, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 37.5%)", "rgb(48, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 37.5%, 0)", "rgba(48, 48, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 37.5%, 0.2)", "rgba(48, 48, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 37.5%, 1)", "rgb(48, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 50%)", "rgb(64, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 50%, 0)", "rgba(64, 64, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 50%, 0.2)", "rgba(64, 64, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 50%, 1)", "rgb(64, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 62.5%)", "rgb(112, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 62.5%, 0)", "rgba(112, 112, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 62.5%, 0.2)", "rgba(112, 112, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 62.5%, 1)", "rgb(112, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 75%)", "rgb(159, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 75%, 0)", "rgba(159, 159, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 75%, 0.2)", "rgba(159, 159, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 75%, 1)", "rgb(159, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 87.5%)", "rgb(207, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 87.5%, 0)", "rgba(207, 207, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 87.5%, 0.2)", "rgba(207, 207, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 87.5%, 1)", "rgb(207, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 12.5%)", "rgb(12, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 12.5%, 0)", "rgba(12, 12, 52, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 12.5%, 0.2)", "rgba(12, 12, 52, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 12.5%, 1)", "rgb(12, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 25%)", "rgb(24, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 25%, 0)", "rgba(24, 24, 104, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 25%, 0.2)", "rgba(24, 24, 104, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 25%, 1)", "rgb(24, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 37.5%)", "rgb(36, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 37.5%, 0)", "rgba(36, 36, 155, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 37.5%, 0.2)", "rgba(36, 36, 155, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 37.5%, 1)", "rgb(36, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 50%)", "rgb(48, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 50%, 0)", "rgba(48, 48, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 50%, 0.2)", "rgba(48, 48, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 50%, 1)", "rgb(48, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 62.5%)", "rgb(100, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 62.5%, 0)", "rgba(100, 100, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 62.5%, 0.2)", "rgba(100, 100, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 62.5%, 1)", "rgb(100, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 75%)", "rgb(151, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 75%, 0)", "rgba(151, 151, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 75%, 0.2)", "rgba(151, 151, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 75%, 1)", "rgb(151, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 87.5%)", "rgb(203, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 87.5%, 0)", "rgba(203, 203, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 87.5%, 0.2)", "rgba(203, 203, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 87.5%, 1)", "rgb(203, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 12.5%)", "rgb(8, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 12.5%, 0)", "rgba(8, 8, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 12.5%, 0.2)", "rgba(8, 8, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 12.5%, 1)", "rgb(8, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 25%)", "rgb(16, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 25%, 0)", "rgba(16, 16, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 25%, 0.2)", "rgba(16, 16, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 25%, 1)", "rgb(16, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 37.5%)", "rgb(24, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 37.5%, 0)", "rgba(24, 24, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 37.5%, 0.2)", "rgba(24, 24, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 37.5%, 1)", "rgb(24, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 50%)", "rgb(32, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 50%, 0)", "rgba(32, 32, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 50%, 0.2)", "rgba(32, 32, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 50%, 1)", "rgb(32, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 62.5%)", "rgb(88, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 62.5%, 0)", "rgba(88, 88, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 62.5%, 0.2)", "rgba(88, 88, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 62.5%, 1)", "rgb(88, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 75%)", "rgb(143, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 75%, 0)", "rgba(143, 143, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 75%, 0.2)", "rgba(143, 143, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 75%, 1)", "rgb(143, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 87.5%)", "rgb(199, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 87.5%, 0)", "rgba(199, 199, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 87.5%, 0.2)", "rgba(199, 199, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 87.5%, 1)", "rgb(199, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 12.5%)", "rgb(4, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 12.5%, 0)", "rgba(4, 4, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 12.5%, 0.2)", "rgba(4, 4, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 12.5%, 1)", "rgb(4, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 25%)", "rgb(8, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 25%, 0)", "rgba(8, 8, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 25%, 0.2)", "rgba(8, 8, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 25%, 1)", "rgb(8, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 37.5%)", "rgb(12, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 37.5%, 0)", "rgba(12, 12, 179, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 37.5%, 0.2)", "rgba(12, 12, 179, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 37.5%, 1)", "rgb(12, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 50%)", "rgb(16, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 50%, 0)", "rgba(16, 16, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 50%, 0.2)", "rgba(16, 16, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 50%, 1)", "rgb(16, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 62.5%)", "rgb(76, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 62.5%, 0)", "rgba(76, 76, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 62.5%, 0.2)", "rgba(76, 76, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 62.5%, 1)", "rgb(76, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 75%)", "rgb(135, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 75%, 0)", "rgba(135, 135, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 75%, 0.2)", "rgba(135, 135, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 75%, 1)", "rgb(135, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 87.5%)", "rgb(195, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 87.5%, 0)", "rgba(195, 195, 251, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 87.5%, 0.2)", "rgba(195, 195, 251, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 87.5%, 1)", "rgb(195, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 12.5%)", "rgb(0, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 12.5%, 0)", "rgba(0, 0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 12.5%, 0.2)", "rgba(0, 0, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 12.5%, 1)", "rgb(0, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 25%)", "rgb(0, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 25%, 0)", "rgba(0, 0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 25%, 0.2)", "rgba(0, 0, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 25%, 1)", "rgb(0, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 37.5%)", "rgb(0, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 37.5%, 0)", "rgba(0, 0, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 37.5%, 0.2)", "rgba(0, 0, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 37.5%, 1)", "rgb(0, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 50%)", "rgb(0, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 50%, 0)", "rgba(0, 0, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 50%, 0.2)", "rgba(0, 0, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 50%, 1)", "rgb(0, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 62.5%)", "rgb(64, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 62.5%, 0)", "rgba(64, 64, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 62.5%, 0.2)", "rgba(64, 64, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 62.5%, 1)", "rgb(64, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 75%)", "rgb(128, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 75%, 0)", "rgba(128, 128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 75%, 0.2)", "rgba(128, 128, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 75%, 1)", "rgb(128, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 87.5%)", "rgb(191, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 87.5%, 0)", "rgba(191, 191, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 87.5%, 0.2)", "rgba(191, 191, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 87.5%, 1)", "rgb(191, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(240, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(240, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 12.5%)", "rgb(32, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 12.5%, 0)", "rgba(32, 28, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 12.5%, 0.2)", "rgba(32, 28, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 12.5%, 1)", "rgb(32, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 25%)", "rgb(64, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 25%, 0)", "rgba(64, 56, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 25%, 0.2)", "rgba(64, 56, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 25%, 1)", "rgb(64, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 37.5%)", "rgb(96, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 37.5%, 0)", "rgba(96, 84, 108, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 37.5%, 0.2)", "rgba(96, 84, 108, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 37.5%, 1)", "rgb(96, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 50%)", "rgb(128, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 50%, 0)", "rgba(128, 112, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 50%, 0.2)", "rgba(128, 112, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 50%, 1)", "rgb(128, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 62.5%)", "rgb(159, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 62.5%, 0)", "rgba(159, 147, 171, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 62.5%, 0.2)", "rgba(159, 147, 171, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 62.5%, 1)", "rgb(159, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 75%)", "rgb(191, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 75%, 0)", "rgba(191, 183, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 75%, 0.2)", "rgba(191, 183, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 75%, 1)", "rgb(191, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 87.5%)", "rgb(223, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 87.5%, 0)", "rgba(223, 219, 227, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 87.5%, 0.2)", "rgba(223, 219, 227, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 87.5%, 1)", "rgb(223, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 12.5%)", "rgb(32, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 12.5%, 0)", "rgba(32, 24, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 12.5%, 0.2)", "rgba(32, 24, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 12.5%, 1)", "rgb(32, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 25%)", "rgb(64, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 25%, 0)", "rgba(64, 48, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 25%, 0.2)", "rgba(64, 48, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 25%, 1)", "rgb(64, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 37.5%)", "rgb(96, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 37.5%, 0)", "rgba(96, 72, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 37.5%, 0.2)", "rgba(96, 72, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 37.5%, 1)", "rgb(96, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 50%)", "rgb(128, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 50%, 0)", "rgba(128, 96, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 50%, 0.2)", "rgba(128, 96, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 50%, 1)", "rgb(128, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 62.5%)", "rgb(159, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 62.5%, 0)", "rgba(159, 135, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 62.5%, 0.2)", "rgba(159, 135, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 62.5%, 1)", "rgb(159, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 75%)", "rgb(191, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 75%, 0)", "rgba(191, 175, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 75%, 0.2)", "rgba(191, 175, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 75%, 1)", "rgb(191, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 87.5%)", "rgb(223, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 87.5%, 0)", "rgba(223, 215, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 87.5%, 0.2)", "rgba(223, 215, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 87.5%, 1)", "rgb(223, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 12.5%)", "rgb(32, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 12.5%, 0)", "rgba(32, 20, 44, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 12.5%, 0.2)", "rgba(32, 20, 44, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 12.5%, 1)", "rgb(32, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 25%)", "rgb(64, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 25%, 0)", "rgba(64, 40, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 25%, 0.2)", "rgba(64, 40, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 25%, 1)", "rgb(64, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 37.5%)", "rgb(96, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 37.5%, 0)", "rgba(96, 60, 131, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 37.5%, 0.2)", "rgba(96, 60, 131, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 37.5%, 1)", "rgb(96, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 50%)", "rgb(128, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 50%, 0)", "rgba(128, 80, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 50%, 0.2)", "rgba(128, 80, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 50%, 1)", "rgb(128, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 62.5%)", "rgb(159, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 62.5%, 0)", "rgba(159, 124, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 62.5%, 0.2)", "rgba(159, 124, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 62.5%, 1)", "rgb(159, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 75%)", "rgb(191, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 75%, 0)", "rgba(191, 167, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 75%, 0.2)", "rgba(191, 167, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 75%, 1)", "rgb(191, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 87.5%)", "rgb(223, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 87.5%, 0)", "rgba(223, 211, 235, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 87.5%, 0.2)", "rgba(223, 211, 235, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 87.5%, 1)", "rgb(223, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 12.5%)", "rgb(32, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 12.5%, 0)", "rgba(32, 16, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 12.5%, 0.2)", "rgba(32, 16, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 12.5%, 1)", "rgb(32, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 25%)", "rgb(64, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 25%, 0)", "rgba(64, 32, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 25%, 0.2)", "rgba(64, 32, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 25%, 1)", "rgb(64, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 37.5%)", "rgb(96, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 37.5%, 0)", "rgba(96, 48, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 37.5%, 0.2)", "rgba(96, 48, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 37.5%, 1)", "rgb(96, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 50%)", "rgb(128, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 50%, 0)", "rgba(128, 64, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 50%, 0.2)", "rgba(128, 64, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 50%, 1)", "rgb(128, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 62.5%)", "rgb(159, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 62.5%, 0)", "rgba(159, 112, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 62.5%, 0.2)", "rgba(159, 112, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 62.5%, 1)", "rgb(159, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 75%)", "rgb(191, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 75%, 0)", "rgba(191, 159, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 75%, 0.2)", "rgba(191, 159, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 75%, 1)", "rgb(191, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 87.5%)", "rgb(223, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 87.5%, 0)", "rgba(223, 207, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 87.5%, 0.2)", "rgba(223, 207, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 87.5%, 1)", "rgb(223, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 12.5%)", "rgb(32, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 12.5%, 0)", "rgba(32, 12, 52, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 12.5%, 0.2)", "rgba(32, 12, 52, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 12.5%, 1)", "rgb(32, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 25%)", "rgb(64, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 25%, 0)", "rgba(64, 24, 104, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 25%, 0.2)", "rgba(64, 24, 104, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 25%, 1)", "rgb(64, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 37.5%)", "rgb(96, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 37.5%, 0)", "rgba(96, 36, 155, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 37.5%, 0.2)", "rgba(96, 36, 155, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 37.5%, 1)", "rgb(96, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 50%)", "rgb(128, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 50%, 0)", "rgba(128, 48, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 50%, 0.2)", "rgba(128, 48, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 50%, 1)", "rgb(128, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 62.5%)", "rgb(159, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 62.5%, 0)", "rgba(159, 100, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 62.5%, 0.2)", "rgba(159, 100, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 62.5%, 1)", "rgb(159, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 75%)", "rgb(191, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 75%, 0)", "rgba(191, 151, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 75%, 0.2)", "rgba(191, 151, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 75%, 1)", "rgb(191, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 87.5%)", "rgb(223, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 87.5%, 0)", "rgba(223, 203, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 87.5%, 0.2)", "rgba(223, 203, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 87.5%, 1)", "rgb(223, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 12.5%)", "rgb(32, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 12.5%, 0)", "rgba(32, 8, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 12.5%, 0.2)", "rgba(32, 8, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 12.5%, 1)", "rgb(32, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 25%)", "rgb(64, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 25%, 0)", "rgba(64, 16, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 25%, 0.2)", "rgba(64, 16, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 25%, 1)", "rgb(64, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 37.5%)", "rgb(96, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 37.5%, 0)", "rgba(96, 24, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 37.5%, 0.2)", "rgba(96, 24, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 37.5%, 1)", "rgb(96, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 50%)", "rgb(128, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 50%, 0)", "rgba(128, 32, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 50%, 0.2)", "rgba(128, 32, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 50%, 1)", "rgb(128, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 62.5%)", "rgb(159, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 62.5%, 0)", "rgba(159, 88, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 62.5%, 0.2)", "rgba(159, 88, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 62.5%, 1)", "rgb(159, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 75%)", "rgb(191, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 75%, 0)", "rgba(191, 143, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 75%, 0.2)", "rgba(191, 143, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 75%, 1)", "rgb(191, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 87.5%)", "rgb(223, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 87.5%, 0)", "rgba(223, 199, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 87.5%, 0.2)", "rgba(223, 199, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 87.5%, 1)", "rgb(223, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 12.5%)", "rgb(32, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 12.5%, 0)", "rgba(32, 4, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 12.5%, 0.2)", "rgba(32, 4, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 12.5%, 1)", "rgb(32, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 25%)", "rgb(64, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 25%, 0)", "rgba(64, 8, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 25%, 0.2)", "rgba(64, 8, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 25%, 1)", "rgb(64, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 37.5%)", "rgb(96, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 37.5%, 0)", "rgba(96, 12, 179, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 37.5%, 0.2)", "rgba(96, 12, 179, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 37.5%, 1)", "rgb(96, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 50%)", "rgb(128, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 50%, 0)", "rgba(128, 16, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 50%, 0.2)", "rgba(128, 16, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 50%, 1)", "rgb(128, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 62.5%)", "rgb(159, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 62.5%, 0)", "rgba(159, 76, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 62.5%, 0.2)", "rgba(159, 76, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 62.5%, 1)", "rgb(159, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 75%)", "rgb(191, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 75%, 0)", "rgba(191, 135, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 75%, 0.2)", "rgba(191, 135, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 75%, 1)", "rgb(191, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 87.5%)", "rgb(223, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 87.5%, 0)", "rgba(223, 195, 251, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 87.5%, 0.2)", "rgba(223, 195, 251, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 87.5%, 1)", "rgb(223, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 12.5%)", "rgb(32, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 12.5%, 0)", "rgba(32, 0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 12.5%, 0.2)", "rgba(32, 0, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 12.5%, 1)", "rgb(32, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 25%)", "rgb(64, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 25%, 0)", "rgba(64, 0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 25%, 0.2)", "rgba(64, 0, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 25%, 1)", "rgb(64, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 37.5%)", "rgb(96, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 37.5%, 0)", "rgba(96, 0, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 37.5%, 0.2)", "rgba(96, 0, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 37.5%, 1)", "rgb(96, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 50%)", "rgb(128, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 50%, 0)", "rgba(128, 0, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 50%, 0.2)", "rgba(128, 0, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 50%, 1)", "rgb(128, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 62.5%)", "rgb(159, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 62.5%, 0)", "rgba(159, 64, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 62.5%, 0.2)", "rgba(159, 64, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 62.5%, 1)", "rgb(159, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 75%)", "rgb(191, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 75%, 0)", "rgba(191, 128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 75%, 0.2)", "rgba(191, 128, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 75%, 1)", "rgb(191, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 87.5%)", "rgb(223, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 87.5%, 0)", "rgba(223, 191, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 87.5%, 0.2)", "rgba(223, 191, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 87.5%, 1)", "rgb(223, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(270, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(270, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 12.5%)", "rgb(36, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 12.5%, 0)", "rgba(36, 28, 36, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 12.5%, 0.2)", "rgba(36, 28, 36, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 12.5%, 1)", "rgb(36, 28, 36)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 25%)", "rgb(72, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 25%, 0)", "rgba(72, 56, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 25%, 0.2)", "rgba(72, 56, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 25%, 1)", "rgb(72, 56, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 37.5%)", "rgb(108, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 37.5%, 0)", "rgba(108, 84, 108, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 37.5%, 0.2)", "rgba(108, 84, 108, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 37.5%, 1)", "rgb(108, 84, 108)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 50%)", "rgb(143, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 50%, 0)", "rgba(143, 112, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 50%, 0.2)", "rgba(143, 112, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 50%, 1)", "rgb(143, 112, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 62.5%)", "rgb(171, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 62.5%, 0)", "rgba(171, 147, 171, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 62.5%, 0.2)", "rgba(171, 147, 171, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 62.5%, 1)", "rgb(171, 147, 171)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 75%)", "rgb(199, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 75%, 0)", "rgba(199, 183, 199, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 75%, 0.2)", "rgba(199, 183, 199, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 75%, 1)", "rgb(199, 183, 199)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 87.5%)", "rgb(227, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 87.5%, 0)", "rgba(227, 219, 227, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 87.5%, 0.2)", "rgba(227, 219, 227, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 87.5%, 1)", "rgb(227, 219, 227)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 12.5%)", "rgb(40, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 12.5%, 0)", "rgba(40, 24, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 12.5%, 0.2)", "rgba(40, 24, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 12.5%, 1)", "rgb(40, 24, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 25%)", "rgb(80, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 25%, 0)", "rgba(80, 48, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 25%, 0.2)", "rgba(80, 48, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 25%, 1)", "rgb(80, 48, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 37.5%)", "rgb(120, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 37.5%, 0)", "rgba(120, 72, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 37.5%, 0.2)", "rgba(120, 72, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 37.5%, 1)", "rgb(120, 72, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 50%)", "rgb(159, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 50%, 0)", "rgba(159, 96, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 50%, 0.2)", "rgba(159, 96, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 50%, 1)", "rgb(159, 96, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 62.5%)", "rgb(183, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 62.5%, 0)", "rgba(183, 135, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 62.5%, 0.2)", "rgba(183, 135, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 62.5%, 1)", "rgb(183, 135, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 75%)", "rgb(207, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 75%, 0)", "rgba(207, 175, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 75%, 0.2)", "rgba(207, 175, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 75%, 1)", "rgb(207, 175, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 87.5%)", "rgb(231, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 87.5%, 0)", "rgba(231, 215, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 87.5%, 0.2)", "rgba(231, 215, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 87.5%, 1)", "rgb(231, 215, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 12.5%)", "rgb(44, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 12.5%, 0)", "rgba(44, 20, 44, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 12.5%, 0.2)", "rgba(44, 20, 44, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 12.5%, 1)", "rgb(44, 20, 44)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 25%)", "rgb(88, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 25%, 0)", "rgba(88, 40, 88, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 25%, 0.2)", "rgba(88, 40, 88, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 25%, 1)", "rgb(88, 40, 88)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 37.5%)", "rgb(131, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 37.5%, 0)", "rgba(131, 60, 131, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 37.5%, 0.2)", "rgba(131, 60, 131, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 37.5%, 1)", "rgb(131, 60, 131)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 50%)", "rgb(175, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 50%, 0)", "rgba(175, 80, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 50%, 0.2)", "rgba(175, 80, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 50%, 1)", "rgb(175, 80, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 62.5%)", "rgb(195, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 62.5%, 0)", "rgba(195, 124, 195, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 62.5%, 0.2)", "rgba(195, 124, 195, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 62.5%, 1)", "rgb(195, 124, 195)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 75%)", "rgb(215, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 75%, 0)", "rgba(215, 167, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 75%, 0.2)", "rgba(215, 167, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 75%, 1)", "rgb(215, 167, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 87.5%)", "rgb(235, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 87.5%, 0)", "rgba(235, 211, 235, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 87.5%, 0.2)", "rgba(235, 211, 235, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 87.5%, 1)", "rgb(235, 211, 235)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 12.5%)", "rgb(48, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 12.5%, 0)", "rgba(48, 16, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 12.5%, 0.2)", "rgba(48, 16, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 12.5%, 1)", "rgb(48, 16, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 25%)", "rgb(96, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 25%, 0)", "rgba(96, 32, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 25%, 0.2)", "rgba(96, 32, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 25%, 1)", "rgb(96, 32, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 37.5%)", "rgb(143, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 37.5%, 0)", "rgba(143, 48, 143, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 37.5%, 0.2)", "rgba(143, 48, 143, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 37.5%, 1)", "rgb(143, 48, 143)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 50%)", "rgb(191, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 50%, 0)", "rgba(191, 64, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 50%, 0.2)", "rgba(191, 64, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 50%, 1)", "rgb(191, 64, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 62.5%)", "rgb(207, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 62.5%, 0)", "rgba(207, 112, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 62.5%, 0.2)", "rgba(207, 112, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 62.5%, 1)", "rgb(207, 112, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 75%)", "rgb(223, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 75%, 0)", "rgba(223, 159, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 75%, 0.2)", "rgba(223, 159, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 75%, 1)", "rgb(223, 159, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 87.5%)", "rgb(239, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 87.5%, 0)", "rgba(239, 207, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 87.5%, 0.2)", "rgba(239, 207, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 87.5%, 1)", "rgb(239, 207, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 12.5%)", "rgb(52, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 12.5%, 0)", "rgba(52, 12, 52, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 12.5%, 0.2)", "rgba(52, 12, 52, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 12.5%, 1)", "rgb(52, 12, 52)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 25%)", "rgb(104, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 25%, 0)", "rgba(104, 24, 104, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 25%, 0.2)", "rgba(104, 24, 104, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 25%, 1)", "rgb(104, 24, 104)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 37.5%)", "rgb(155, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 37.5%, 0)", "rgba(155, 36, 155, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 37.5%, 0.2)", "rgba(155, 36, 155, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 37.5%, 1)", "rgb(155, 36, 155)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 50%)", "rgb(207, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 50%, 0)", "rgba(207, 48, 207, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 50%, 0.2)", "rgba(207, 48, 207, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 50%, 1)", "rgb(207, 48, 207)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 62.5%)", "rgb(219, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 62.5%, 0)", "rgba(219, 100, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 62.5%, 0.2)", "rgba(219, 100, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 62.5%, 1)", "rgb(219, 100, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 75%)", "rgb(231, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 75%, 0)", "rgba(231, 151, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 75%, 0.2)", "rgba(231, 151, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 75%, 1)", "rgb(231, 151, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 87.5%)", "rgb(243, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 87.5%, 0)", "rgba(243, 203, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 87.5%, 0.2)", "rgba(243, 203, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 87.5%, 1)", "rgb(243, 203, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 12.5%)", "rgb(56, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 12.5%, 0)", "rgba(56, 8, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 12.5%, 0.2)", "rgba(56, 8, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 12.5%, 1)", "rgb(56, 8, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 25%)", "rgb(112, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 25%, 0)", "rgba(112, 16, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 25%, 0.2)", "rgba(112, 16, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 25%, 1)", "rgb(112, 16, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 37.5%)", "rgb(167, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 37.5%, 0)", "rgba(167, 24, 167, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 37.5%, 0.2)", "rgba(167, 24, 167, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 37.5%, 1)", "rgb(167, 24, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 50%)", "rgb(223, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 50%, 0)", "rgba(223, 32, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 50%, 0.2)", "rgba(223, 32, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 50%, 1)", "rgb(223, 32, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 62.5%)", "rgb(231, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 62.5%, 0)", "rgba(231, 88, 231, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 62.5%, 0.2)", "rgba(231, 88, 231, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 62.5%, 1)", "rgb(231, 88, 231)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 75%)", "rgb(239, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 75%, 0)", "rgba(239, 143, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 75%, 0.2)", "rgba(239, 143, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 75%, 1)", "rgb(239, 143, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 87.5%)", "rgb(247, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 87.5%, 0)", "rgba(247, 199, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 87.5%, 0.2)", "rgba(247, 199, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 87.5%, 1)", "rgb(247, 199, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 12.5%)", "rgb(60, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 12.5%, 0)", "rgba(60, 4, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 12.5%, 0.2)", "rgba(60, 4, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 12.5%, 1)", "rgb(60, 4, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 25%)", "rgb(120, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 25%, 0)", "rgba(120, 8, 120, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 25%, 0.2)", "rgba(120, 8, 120, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 25%, 1)", "rgb(120, 8, 120)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 37.5%)", "rgb(179, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 37.5%, 0)", "rgba(179, 12, 179, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 37.5%, 0.2)", "rgba(179, 12, 179, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 37.5%, 1)", "rgb(179, 12, 179)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 50%)", "rgb(239, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 50%, 0)", "rgba(239, 16, 239, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 50%, 0.2)", "rgba(239, 16, 239, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 50%, 1)", "rgb(239, 16, 239)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 62.5%)", "rgb(243, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 62.5%, 0)", "rgba(243, 76, 243, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 62.5%, 0.2)", "rgba(243, 76, 243, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 62.5%, 1)", "rgb(243, 76, 243)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 75%)", "rgb(247, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 75%, 0)", "rgba(247, 135, 247, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 75%, 0.2)", "rgba(247, 135, 247, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 75%, 1)", "rgb(247, 135, 247)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 87.5%)", "rgb(251, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 87.5%, 0)", "rgba(251, 195, 251, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 87.5%, 0.2)", "rgba(251, 195, 251, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 87.5%, 1)", "rgb(251, 195, 251)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 12.5%)", "rgb(64, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 12.5%, 0)", "rgba(64, 0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 12.5%, 0.2)", "rgba(64, 0, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 12.5%, 1)", "rgb(64, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 25%)", "rgb(128, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 25%, 0)", "rgba(128, 0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 25%, 0.2)", "rgba(128, 0, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 25%, 1)", "rgb(128, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 37.5%)", "rgb(191, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 37.5%, 0)", "rgba(191, 0, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 37.5%, 0.2)", "rgba(191, 0, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 37.5%, 1)", "rgb(191, 0, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 50%)", "rgb(255, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 50%, 0)", "rgba(255, 0, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 50%, 0.2)", "rgba(255, 0, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 50%, 1)", "rgb(255, 0, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 62.5%)", "rgb(255, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 62.5%, 0)", "rgba(255, 64, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 62.5%, 0.2)", "rgba(255, 64, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 62.5%, 1)", "rgb(255, 64, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 75%)", "rgb(255, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 75%, 0)", "rgba(255, 128, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 75%, 0.2)", "rgba(255, 128, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 75%, 1)", "rgb(255, 128, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 87.5%)", "rgb(255, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 87.5%, 0)", "rgba(255, 191, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 87.5%, 0.2)", "rgba(255, 191, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 87.5%, 1)", "rgb(255, 191, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(300, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(300, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 12.5%)", "rgb(36, 28, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 12.5%, 0)", "rgba(36, 28, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 12.5%, 0.2)", "rgba(36, 28, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 12.5%, 1)", "rgb(36, 28, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 25%)", "rgb(72, 56, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 25%, 0)", "rgba(72, 56, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 25%, 0.2)", "rgba(72, 56, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 25%, 1)", "rgb(72, 56, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 37.5%)", "rgb(108, 84, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 37.5%, 0)", "rgba(108, 84, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 37.5%, 0.2)", "rgba(108, 84, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 37.5%, 1)", "rgb(108, 84, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 50%)", "rgb(143, 112, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 50%, 0)", "rgba(143, 112, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 50%, 0.2)", "rgba(143, 112, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 50%, 1)", "rgb(143, 112, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 62.5%)", "rgb(171, 147, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 62.5%, 0)", "rgba(171, 147, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 62.5%, 0.2)", "rgba(171, 147, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 62.5%, 1)", "rgb(171, 147, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 75%)", "rgb(199, 183, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 75%, 0)", "rgba(199, 183, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 75%, 0.2)", "rgba(199, 183, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 75%, 1)", "rgb(199, 183, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 87.5%)", "rgb(227, 219, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 87.5%, 0)", "rgba(227, 219, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 87.5%, 0.2)", "rgba(227, 219, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 87.5%, 1)", "rgb(227, 219, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 12.5%)", "rgb(40, 24, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 12.5%, 0)", "rgba(40, 24, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 12.5%, 0.2)", "rgba(40, 24, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 12.5%, 1)", "rgb(40, 24, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 25%)", "rgb(80, 48, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 25%, 0)", "rgba(80, 48, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 25%, 0.2)", "rgba(80, 48, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 25%, 1)", "rgb(80, 48, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 37.5%)", "rgb(120, 72, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 37.5%, 0)", "rgba(120, 72, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 37.5%, 0.2)", "rgba(120, 72, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 37.5%, 1)", "rgb(120, 72, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 50%)", "rgb(159, 96, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 50%, 0)", "rgba(159, 96, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 50%, 0.2)", "rgba(159, 96, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 50%, 1)", "rgb(159, 96, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 62.5%)", "rgb(183, 135, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 62.5%, 0)", "rgba(183, 135, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 62.5%, 0.2)", "rgba(183, 135, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 62.5%, 1)", "rgb(183, 135, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 75%)", "rgb(207, 175, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 75%, 0)", "rgba(207, 175, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 75%, 0.2)", "rgba(207, 175, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 75%, 1)", "rgb(207, 175, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 87.5%)", "rgb(231, 215, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 87.5%, 0)", "rgba(231, 215, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 87.5%, 0.2)", "rgba(231, 215, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 87.5%, 1)", "rgb(231, 215, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 12.5%)", "rgb(44, 20, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 12.5%, 0)", "rgba(44, 20, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 12.5%, 0.2)", "rgba(44, 20, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 12.5%, 1)", "rgb(44, 20, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 25%)", "rgb(88, 40, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 25%, 0)", "rgba(88, 40, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 25%, 0.2)", "rgba(88, 40, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 25%, 1)", "rgb(88, 40, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 37.5%)", "rgb(131, 60, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 37.5%, 0)", "rgba(131, 60, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 37.5%, 0.2)", "rgba(131, 60, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 37.5%, 1)", "rgb(131, 60, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 50%)", "rgb(175, 80, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 50%, 0)", "rgba(175, 80, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 50%, 0.2)", "rgba(175, 80, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 50%, 1)", "rgb(175, 80, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 62.5%)", "rgb(195, 124, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 62.5%, 0)", "rgba(195, 124, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 62.5%, 0.2)", "rgba(195, 124, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 62.5%, 1)", "rgb(195, 124, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 75%)", "rgb(215, 167, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 75%, 0)", "rgba(215, 167, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 75%, 0.2)", "rgba(215, 167, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 75%, 1)", "rgb(215, 167, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 87.5%)", "rgb(235, 211, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 87.5%, 0)", "rgba(235, 211, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 87.5%, 0.2)", "rgba(235, 211, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 87.5%, 1)", "rgb(235, 211, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 37.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 37.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 12.5%)", "rgb(48, 16, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 12.5%, 0)", "rgba(48, 16, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 12.5%, 0.2)", "rgba(48, 16, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 12.5%, 1)", "rgb(48, 16, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 25%)", "rgb(96, 32, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 25%, 0)", "rgba(96, 32, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 25%, 0.2)", "rgba(96, 32, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 25%, 1)", "rgb(96, 32, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 37.5%)", "rgb(143, 48, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 37.5%, 0)", "rgba(143, 48, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 37.5%, 0.2)", "rgba(143, 48, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 37.5%, 1)", "rgb(143, 48, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 50%)", "rgb(191, 64, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 50%, 0)", "rgba(191, 64, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 50%, 0.2)", "rgba(191, 64, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 50%, 1)", "rgb(191, 64, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 62.5%)", "rgb(207, 112, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 62.5%, 0)", "rgba(207, 112, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 62.5%, 0.2)", "rgba(207, 112, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 62.5%, 1)", "rgb(207, 112, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 75%)", "rgb(223, 159, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 75%, 0)", "rgba(223, 159, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 75%, 0.2)", "rgba(223, 159, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 75%, 1)", "rgb(223, 159, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 87.5%)", "rgb(239, 207, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 87.5%, 0)", "rgba(239, 207, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 87.5%, 0.2)", "rgba(239, 207, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 87.5%, 1)", "rgb(239, 207, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 50%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 50%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 12.5%)", "rgb(52, 12, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 12.5%, 0)", "rgba(52, 12, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 12.5%, 0.2)", "rgba(52, 12, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 12.5%, 1)", "rgb(52, 12, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 25%)", "rgb(104, 24, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 25%, 0)", "rgba(104, 24, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 25%, 0.2)", "rgba(104, 24, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 25%, 1)", "rgb(104, 24, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 37.5%)", "rgb(155, 36, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 37.5%, 0)", "rgba(155, 36, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 37.5%, 0.2)", "rgba(155, 36, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 37.5%, 1)", "rgb(155, 36, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 50%)", "rgb(207, 48, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 50%, 0)", "rgba(207, 48, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 50%, 0.2)", "rgba(207, 48, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 50%, 1)", "rgb(207, 48, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 62.5%)", "rgb(219, 100, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 62.5%, 0)", "rgba(219, 100, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 62.5%, 0.2)", "rgba(219, 100, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 62.5%, 1)", "rgb(219, 100, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 75%)", "rgb(231, 151, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 75%, 0)", "rgba(231, 151, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 75%, 0.2)", "rgba(231, 151, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 75%, 1)", "rgb(231, 151, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 87.5%)", "rgb(243, 203, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 87.5%, 0)", "rgba(243, 203, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 87.5%, 0.2)", "rgba(243, 203, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 87.5%, 1)", "rgb(243, 203, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 62.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 62.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 12.5%)", "rgb(56, 8, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 12.5%, 0)", "rgba(56, 8, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 12.5%, 0.2)", "rgba(56, 8, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 12.5%, 1)", "rgb(56, 8, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 25%)", "rgb(112, 16, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 25%, 0)", "rgba(112, 16, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 25%, 0.2)", "rgba(112, 16, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 25%, 1)", "rgb(112, 16, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 37.5%)", "rgb(167, 24, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 37.5%, 0)", "rgba(167, 24, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 37.5%, 0.2)", "rgba(167, 24, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 37.5%, 1)", "rgb(167, 24, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 50%)", "rgb(223, 32, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 50%, 0)", "rgba(223, 32, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 50%, 0.2)", "rgba(223, 32, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 50%, 1)", "rgb(223, 32, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 62.5%)", "rgb(231, 88, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 62.5%, 0)", "rgba(231, 88, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 62.5%, 0.2)", "rgba(231, 88, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 62.5%, 1)", "rgb(231, 88, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 75%)", "rgb(239, 143, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 75%, 0)", "rgba(239, 143, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 75%, 0.2)", "rgba(239, 143, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 75%, 1)", "rgb(239, 143, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 87.5%)", "rgb(247, 199, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 87.5%, 0)", "rgba(247, 199, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 87.5%, 0.2)", "rgba(247, 199, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 87.5%, 1)", "rgb(247, 199, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 75%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 75%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 12.5%)", "rgb(60, 4, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 12.5%, 0)", "rgba(60, 4, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 12.5%, 0.2)", "rgba(60, 4, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 12.5%, 1)", "rgb(60, 4, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 25%)", "rgb(120, 8, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 25%, 0)", "rgba(120, 8, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 25%, 0.2)", "rgba(120, 8, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 25%, 1)", "rgb(120, 8, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 37.5%)", "rgb(179, 12, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 37.5%, 0)", "rgba(179, 12, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 37.5%, 0.2)", "rgba(179, 12, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 37.5%, 1)", "rgb(179, 12, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 50%)", "rgb(239, 16, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 50%, 0)", "rgba(239, 16, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 50%, 0.2)", "rgba(239, 16, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 50%, 1)", "rgb(239, 16, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 62.5%)", "rgb(243, 76, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 62.5%, 0)", "rgba(243, 76, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 62.5%, 0.2)", "rgba(243, 76, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 62.5%, 1)", "rgb(243, 76, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 75%)", "rgb(247, 135, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 75%, 0)", "rgba(247, 135, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 75%, 0.2)", "rgba(247, 135, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 75%, 1)", "rgb(247, 135, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 87.5%)", "rgb(251, 195, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 87.5%, 0)", "rgba(251, 195, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 87.5%, 0.2)", "rgba(251, 195, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 87.5%, 1)", "rgb(251, 195, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 87.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 87.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 12.5%)", "rgb(64, 0, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 12.5%, 0)", "rgba(64, 0, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 12.5%, 0.2)", "rgba(64, 0, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 12.5%, 1)", "rgb(64, 0, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 25%)", "rgb(128, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 25%, 0)", "rgba(128, 0, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 25%, 0.2)", "rgba(128, 0, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 25%, 1)", "rgb(128, 0, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 37.5%)", "rgb(191, 0, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 37.5%, 0)", "rgba(191, 0, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 37.5%, 0.2)", "rgba(191, 0, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 37.5%, 1)", "rgb(191, 0, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 50%)", "rgb(255, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 50%, 0)", "rgba(255, 0, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 50%, 0.2)", "rgba(255, 0, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 50%, 1)", "rgb(255, 0, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 62.5%)", "rgb(255, 64, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 62.5%, 0)", "rgba(255, 64, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 62.5%, 0.2)", "rgba(255, 64, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 62.5%, 1)", "rgb(255, 64, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 75%)", "rgb(255, 128, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 75%, 0)", "rgba(255, 128, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 75%, 0.2)", "rgba(255, 128, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 75%, 1)", "rgb(255, 128, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 87.5%)", "rgb(255, 191, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 87.5%, 0)", "rgba(255, 191, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 87.5%, 0.2)", "rgba(255, 191, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 87.5%, 1)", "rgb(255, 191, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(330, 100%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(330, 100%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 12.5%)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 12.5%, 0)", "rgba(32, 32, 32, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 12.5%, 0.2)", "rgba(32, 32, 32, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 12.5%, 1)", "rgb(32, 32, 32)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 25%)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 25%, 0)", "rgba(64, 64, 64, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 25%, 0.2)", "rgba(64, 64, 64, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 25%, 1)", "rgb(64, 64, 64)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 37.5%)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 37.5%, 0)", "rgba(96, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 37.5%, 0.2)", "rgba(96, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 37.5%, 1)", "rgb(96, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 50%)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 50%, 0)", "rgba(128, 128, 128, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 50%, 0.2)", "rgba(128, 128, 128, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 50%, 1)", "rgb(128, 128, 128)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 62.5%)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 62.5%, 0)", "rgba(159, 159, 159, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 62.5%, 0.2)", "rgba(159, 159, 159, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 62.5%, 1)", "rgb(159, 159, 159)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 75%)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 75%, 0)", "rgba(191, 191, 191, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 75%, 0.2)", "rgba(191, 191, 191, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 75%, 1)", "rgb(191, 191, 191)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 87.5%)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 87.5%, 0)", "rgba(223, 223, 223, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 87.5%, 0.2)", "rgba(223, 223, 223, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 87.5%, 1)", "rgb(223, 223, 223)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 0%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 0%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 12.5%)", "rgb(36, 28, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 12.5%, 0)", "rgba(36, 28, 28, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 12.5%, 0.2)", "rgba(36, 28, 28, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 12.5%, 1)", "rgb(36, 28, 28)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 25%)", "rgb(72, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 25%, 0)", "rgba(72, 56, 56, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 25%, 0.2)", "rgba(72, 56, 56, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 25%, 1)", "rgb(72, 56, 56)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 37.5%)", "rgb(108, 84, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 37.5%, 0)", "rgba(108, 84, 84, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 37.5%, 0.2)", "rgba(108, 84, 84, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 37.5%, 1)", "rgb(108, 84, 84)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 50%)", "rgb(143, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 50%, 0)", "rgba(143, 112, 112, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 50%, 0.2)", "rgba(143, 112, 112, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 50%, 1)", "rgb(143, 112, 112)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 62.5%)", "rgb(171, 147, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 62.5%, 0)", "rgba(171, 147, 147, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 62.5%, 0.2)", "rgba(171, 147, 147, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 62.5%, 1)", "rgb(171, 147, 147)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 75%)", "rgb(199, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 75%, 0)", "rgba(199, 183, 183, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 75%, 0.2)", "rgba(199, 183, 183, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 75%, 1)", "rgb(199, 183, 183)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 87.5%)", "rgb(227, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 87.5%, 0)", "rgba(227, 219, 219, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 87.5%, 0.2)", "rgba(227, 219, 219, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 87.5%, 1)", "rgb(227, 219, 219)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 12.5%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 12.5%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 12.5%)", "rgb(40, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 12.5%, 0)", "rgba(40, 24, 24, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 12.5%, 0.2)", "rgba(40, 24, 24, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 12.5%, 1)", "rgb(40, 24, 24)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 25%)", "rgb(80, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 25%, 0)", "rgba(80, 48, 48, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 25%, 0.2)", "rgba(80, 48, 48, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 25%, 1)", "rgb(80, 48, 48)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 37.5%)", "rgb(120, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 37.5%, 0)", "rgba(120, 72, 72, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 37.5%, 0.2)", "rgba(120, 72, 72, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 37.5%, 1)", "rgb(120, 72, 72)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 50%)", "rgb(159, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 50%, 0)", "rgba(159, 96, 96, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 50%, 0.2)", "rgba(159, 96, 96, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 50%, 1)", "rgb(159, 96, 96)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 62.5%)", "rgb(183, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 62.5%, 0)", "rgba(183, 135, 135, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 62.5%, 0.2)", "rgba(183, 135, 135, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 62.5%, 1)", "rgb(183, 135, 135)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 75%)", "rgb(207, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 75%, 0)", "rgba(207, 175, 175, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 75%, 0.2)", "rgba(207, 175, 175, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 75%, 1)", "rgb(207, 175, 175)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 87.5%)", "rgb(231, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 87.5%, 0)", "rgba(231, 215, 215, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 87.5%, 0.2)", "rgba(231, 215, 215, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 87.5%, 1)", "rgb(231, 215, 215)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 25%, 100%)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 100%, 0)", "rgba(255, 255, 255, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 100%, 0.2)", "rgba(255, 255, 255, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 25%, 100%, 1)", "rgb(255, 255, 255)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 0%)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 0%, 0)", "rgba(0, 0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 0%, 0.2)", "rgba(0, 0, 0, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 0%, 1)", "rgb(0, 0, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 12.5%)", "rgb(44, 20, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 12.5%, 0)", "rgba(44, 20, 20, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 12.5%, 0.2)", "rgba(44, 20, 20, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 12.5%, 1)", "rgb(44, 20, 20)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 25%)", "rgb(88, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 25%, 0)", "rgba(88, 40, 40, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 25%, 0.2)", "rgba(88, 40, 40, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 25%, 1)", "rgb(88, 40, 40)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 37.5%)", "rgb(131, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 37.5%, 0)", "rgba(131, 60, 60, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 37.5%, 0.2)", "rgba(131, 60, 60, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 37.5%, 1)", "rgb(131, 60, 60)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 50%)", "rgb(175, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 50%, 0)", "rgba(175, 80, 80, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 50%, 0.2)", "rgba(175, 80, 80, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 50%, 1)", "rgb(175, 80, 80)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 62.5%)", "rgb(195, 124, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 62.5%, 0)", "rgba(195, 124, 124, 0)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 62.5%, 0.2)", "rgba(195, 124, 124, 0.2)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 62.5%, 1)", "rgb(195, 124, 124)", "HSL/HSLA value should parse and round correctly"],

    ["hsl(360, 37.5%, 75%)", "rgb(215, 167, 167)", "HSL/HSLA value should parse and round correctly"],

    ["hsla(360, 37.5%, 75%, 0)", "rgba(215, 167, 167, 0)", "HSL/HSLA value should parse and round correctly"],

];

for (const test of tests) {

    test_computed_value("color", test[0], test[1], test[2] ? `[${test[2]}]` : undefined);

</script>

</body>

</html>

Source code

Revision control

Copy as Markdown

Other Tools

Test Info: