@less/test-data 4.4.0 → 4.4.3

package/tests-unit/javascript/styles.config.cjs

@@ -0,0 +1,7 @@
+module.exports = {
+  language: {
+    less: {
+      "javascriptEnabled": true
+    }
+  }
+};

package/tests-unit/layer/assets/import/layer-import.less

@@ -0,0 +1,4 @@
+.layer-import {
+  color: indigo;
+}
+

package/tests-unit/layer/import/layer-import.less

@@ -0,0 +1,5 @@
+.sub-rule {
+    ul {
+        color: white;
+    }
+}

package/{css/_main → tests-unit/layer}/layer.css

@@ -69,3 +69,25 @@
 .parent:hover {
   background: lightgray;
 }
+@layer foo.baz {
+  .bar {
+    font-weight: bold;
+  }
+}
+@layer framework {
+  @layer layout {
+    .container {
+      display: grid;
+      gap: 2rem;
+    }
+  }
+}
+@layer framework.layout {
+  main {
+    padding: 2rem;
+  }
+  p {
+    margin-block: 1rem;
+    color: #555;
+  }
+}

package/{less/_main → tests-unit/layer}/layer.less

@@ -85,3 +85,30 @@
         background: lightgray;
     }
 }
+
+@layer foo.baz {
+   .bar {
+       font-weight: bold;
+   }
+}
+
+@layer framework {
+    @layer layout {
+        .container {
+            display: grid;
+            gap: 2rem;
+        }
+    }
+}
+
+@layer framework.layout {
+    main {
+        padding: 2rem;
+    }
+    p {
+        margin-block: 1rem;
+        color: #555;
+    }
+}
+
+

package/{less/_main → tests-unit/lazy-eval}/lazy-eval.less

@@ -1,3 +1,4 @@
+// Lazy evaluation tests
 @var: @a;
 @a: 100%;
 

package/{css/_main → tests-unit/media}/media.css

@@ -241,11 +241,6 @@
     background: green;
   }
 }
-@media (example, all), speech {
-  body {
-    background: green;
-  }
-}
 @media (min-orientation: portrait) {
   body {
     background: green;
@@ -269,3 +264,8 @@
     padding: 0;
   }
 }
+@media print, (max-width: 992px) {
+  div {
+    color: red;
+  }
+}

package/{less/_main → tests-unit/media}/media.less

@@ -1,4 +1,3 @@
-
 // For now, variables can't be declared inside @media blocks.
 
 @var: 42;
@@ -264,12 +263,6 @@
   }
 }
 
-@media (example, all,), speech { 
-  body { 
-    background: green; 
-  }
-}
-
 @media (min-orientation:portrait) {
   body { 
     background: green; 
@@ -297,3 +290,9 @@
     }
   }
 }
+
+@media print, (max-width: 992px) {
+    div {
+        color: red;
+    }
+}

package/{less/_main → tests-unit/merge}/merge.less

@@ -1,3 +1,4 @@
+// Merge functionality tests
 .first-transform() {
   transform+: rotate(90deg), skew(30deg);
 }

package/{less/_main → tests-unit/mixin-noparens}/mixin-noparens.less

@@ -6,4 +6,4 @@
 #container {
   color: black;
   #theme > .mixin;
-}
+}

package/tests-unit/mixins/maps.css

@@ -0,0 +1,6 @@
+.maps h2 {
+  width: 10px;
+}
+.maps h1 {
+  color: white;
+}

package/tests-unit/mixins/maps.less

@@ -0,0 +1,15 @@
+.maps {
+    @a: 10;
+    h2 { width: unit(@a, px); }
+
+    .mk-map() {
+        text: white;
+        background: black;
+    }
+
+    @p: .mk-map();
+
+    h1 { color: @p[text]; }
+}
+
+

package/tests-unit/mixins/mixins-advanced.css

@@ -0,0 +1,41 @@
+.test-expanded {
+  a: 1px;
+  b: 2px;
+}
+.test-multi-def {
+  small: 10;
+  large: 15;
+}
+.test-conditions {
+  large: 15;
+  small: 5;
+}
+.test-no-args-filter {
+  no-args: true;
+  with-args: 10;
+}
+.test-recursive {
+  level: 3;
+  level: 2;
+  level: 1;
+  done: true;
+}
+.test-namespace-path {
+  from-namespace: true;
+}
+.test-important {
+  important: true !important;
+}
+.test-multi {
+  value1: 1;
+  value2: 2;
+}
+.test-named {
+  a: A;
+  b: B;
+}
+.test-array-expand {
+  a: 1;
+  b: 2;
+  c: 3;
+}

package/tests-unit/mixins/mixins-advanced.less

@@ -0,0 +1,109 @@
+// Advanced mixin call tests to cover edge cases
+
+// Mixin call with expanded arguments
+.mixin(@a, @b) {
+  a: @a;
+  b: @b;
+}
+@args: 1px, 2px;
+.test-expanded {
+  .mixin(@args...);
+}
+
+// Mixin call with condition matching and multiple definitions
+.mixin-multi-def(@x: 10) when (@x > 10) {
+  large: @x;
+}
+.mixin-multi-def(@x: 10) when (@x <= 10) {
+  small: @x;
+}
+.test-multi-def {
+  .mixin-multi-def();
+  .mixin-multi-def(15);
+}
+
+// Mixin call with condition matching
+.mixin-guarded(@x) when (@x > 10) {
+  large: @x;
+}
+.mixin-guarded(@x) when (@x <= 10) {
+  small: @x;
+}
+.test-conditions {
+  .mixin-guarded(15);
+  .mixin-guarded(5);
+}
+
+// Mixin call with no arguments filter
+.mixin-no-args() {
+  no-args: true;
+}
+.mixin-no-args(@x) {
+  with-args: @x;
+}
+.test-no-args-filter {
+  .mixin-no-args();
+  .mixin-no-args(10);
+}
+
+// Mixin call with recursive mixin
+.mixin-recursive(@n) when (@n > 0) {
+  level: @n;
+  .mixin-recursive(@n - 1);
+}
+.mixin-recursive(@n) when (@n <= 0) {
+  done: true;
+}
+.test-recursive {
+  .mixin-recursive(3);
+}
+
+// Mixin call with namespace path
+#namespace {
+  .mixin() {
+    from-namespace: true;
+  }
+}
+.test-namespace-path {
+  #namespace > .mixin();
+}
+
+// Mixin call with important flag
+.mixin-important() {
+  important: true;
+}
+.test-important {
+  .mixin-important() !important;
+}
+
+// Mixin call with multiple candidates
+.mixin-multi(@x: 1) {
+  value1: @x;
+}
+.mixin-multi(@x: 2) {
+  value2: @x;
+}
+.test-multi {
+  .mixin-multi();
+}
+
+// Mixin call with named arguments
+.mixin-named(@a: a, @b: b) {
+  a: @a;
+  b: @b;
+}
+.test-named {
+  .mixin-named(@b: B, @a: A);
+}
+
+// Mixin call with expanded array
+.mixin-array(@a, @b, @c) {
+  a: @a;
+  b: @b;
+  c: @c;
+}
+@array: 1, 2, 3;
+.test-array-expand {
+  .mixin-array(@array...);
+}
+

package/{less/_main → tests-unit/mixins}/mixins.less

@@ -142,4 +142,4 @@ h3 { .margin_between(15px, 5px); }
 }
 .foo {
   .clearfix();
-}
+}

package/{less/_main → tests-unit/mixins-important}/mixins-important.less

@@ -50,4 +50,3 @@
 .class2-2421 {
     .test-ruleMixin-2421();
 }
-

package/{css/_main → tests-unit/mixins-interpolated}/mixins-interpolated.css

@@ -1,4 +1,4 @@
-.123 {
+.\123 {
   a: 0;
 }
 .foo {

package/{less/_main → tests-unit/mixins-interpolated}/mixins-interpolated.less

@@ -1,5 +1,4 @@
-
-@a0: 123;
+@a0: \123;
 @a1: foo;
 @a2: ~".foo";
 @a4: ~"#foo";
@@ -25,7 +24,7 @@
 }
 
 mi-test-a {
-    .123();
+    .\123();
     .foo();
     #foo();
 }

package/{less/_main → tests-unit/mixins-named-args}/mixins-named-args.less

@@ -33,4 +33,4 @@
 
 .named-args3 {
   .mixin2(@b: 30%, @c: #123456);
-}
+}

package/tests-unit/namespace-targeted/namespace-targeted.css

@@ -0,0 +1,9 @@
+#namespace {
+  my-prop: prop-value;
+}
+.test-prop-interp {
+  value: prop-value;
+}
+#namespace-with-prop {
+  existing-prop: value;
+}

package/tests-unit/namespace-targeted/namespace-targeted.less

@@ -0,0 +1,33 @@
+// Targeted tests for specific uncovered lines in namespace-value.js
+
+// Lines 51-52: $@var interpolation (property interpolation with variable)
+// This tests: name.substring(0, 2) === '$@'
+// The syntax is #namespace[$@var-name] where @var-name contains the property name
+@prop-name: my-prop;
+#namespace {
+  my-prop: prop-value;
+}
+.test-prop-interp {
+  value: #namespace[$@prop-name];
+}
+
+// Lines 43-47: Variable not found error path
+// Access a variable that doesn't exist in the namespace
+#namespace-with-var {
+  @existing-var: value;
+}
+.test-var-not-found {
+  // This will error: variable @nonexistent-var not found
+  // color: #namespace-with-var[@nonexistent-var];
+}
+
+// Lines 61-65: Property not found error path
+// Access a property that doesn't exist in the namespace
+#namespace-with-prop {
+  existing-prop: value;
+}
+.test-prop-not-found {
+  // This will error: property "nonexistent-prop" not found
+  // value: #namespace-with-prop[$nonexistent-prop];
+}
+

package/tests-unit/nesting/nesting.css

@@ -0,0 +1,24 @@
+.nesting-parent {
+  color: red;
+}
+.nesting-parent .nesting-child {
+  color: blue;
+}
+.nesting-parent .nesting-child .nesting-grandchild {
+  color: green;
+}
+.nesting-parent:hover {
+  color: orange;
+}
+.nesting-parent.modifier {
+  color: purple;
+}
+.correctly-exit-calc-mode h2 {
+  width: 10px;
+}
+.correctly-exit-calc-mode div {
+  width: calc(100px * 2);
+}
+.correctly-exit-calc-mode h1 {
+  color: white;
+}

package/tests-unit/nesting/nesting.less

@@ -0,0 +1,37 @@
+.nesting-parent {
+  color: red;
+  
+  .nesting-child {
+    color: blue;
+    
+    .nesting-grandchild {
+      color: green;
+    }
+  }
+  
+  &:hover {
+    color: orange;
+  }
+  
+  &.modifier {
+    color: purple;
+  }
+}
+
+.correctly-exit-calc-mode {
+    @a: 10;
+    h2 { width: unit(@a, px); }
+
+    div { width: calc(100px * 2); }
+
+    .mk-map() {
+        text: white;
+        background: black;
+    }
+
+    @p: .mk-map();
+
+    h1 { color: @p[text]; }
+}
+
+

package/{less/_main → tests-unit/no-output}/no-output.less

@@ -1,2 +1,2 @@
 .mixin() {
-}
+}

package/tests-unit/operations/operations-advanced.css

@@ -0,0 +1,33 @@
+.test-math-off {
+  result: 15px;
+}
+.test-dim-to-color {
+  result: #ff0a0a;
+}
+.test-color-to-dim {
+  result: #ff0a0a;
+}
+.test-division {
+  result: 10px / 2 * 2;
+}
+.test-nested {
+  result: 30px;
+}
+.test-spaced {
+  result: 15px;
+}
+.test-non-spaced {
+  result: 15px;
+}
+.test-div {
+  result: 10px / 2;
+}
+.test-op-operands {
+  result: 150px;
+}
+.test-math-context {
+  add: 15;
+  sub: 5;
+  mul: 50;
+  div: 10 / 5;
+}

package/tests-unit/operations/operations-advanced.less

@@ -0,0 +1,76 @@
+// Advanced operation tests to cover edge cases
+
+// Operations with math off
+@math-off: true;
+.test-math-off {
+  @a: 10px;
+  @b: 5px;
+  result: @a + @b;
+}
+
+// Operations with Dimension to Color conversion
+@dimension: 10px;
+@color: #ff0000;
+.test-dim-to-color {
+  // This should convert dimension to color for operation
+  result: @dimension + @color;
+}
+
+// Operations with Color to Dimension conversion
+.test-color-to-dim {
+  result: @color + @dimension;
+}
+
+// Operations with division and PARENS_DIVISION math mode
+@div-op: (10px / 2);
+.test-division {
+  result: @div-op * 2;
+}
+
+// Operations with nested operations
+@nested: (10px + 5px) * 2;
+.test-nested {
+  result: @nested;
+}
+
+// Operations with spaced operators
+@spaced: 10px + 5px;
+.test-spaced {
+  result: @spaced;
+}
+
+// Operations with non-spaced operators
+@non-spaced: 10px+5px;
+.test-non-spaced {
+  result: @non-spaced;
+}
+
+// Operations with division operator
+@div-op: 10px / 2;
+.test-div {
+  result: @div-op;
+}
+
+// Operations with invalid types (should error, but test the path)
+.test-invalid {
+  // This will error, but tests the error path
+  // result: "string" + 10px;
+}
+
+// Operations with Operation operands
+@op1: 10px + 5px;
+@op2: 20px - 10px;
+.test-op-operands {
+  result: @op1 * @op2;
+}
+
+// Operations with math context
+.test-math-context {
+  @a: 10;
+  @b: 5;
+  add: @a + @b;
+  sub: @a - @b;
+  mul: @a * @b;
+  div: @a / @b;
+}
+

package/{less/_main → tests-unit/operations}/operations.less

@@ -1,3 +1,4 @@
+// Mathematical operations tests
 #operations {
   color: (#110000 + #000011 + #001100); // #111111
   color-2: (yellow - #070707);

package/{less/_main → tests-unit/parse-interpolation}/parse-interpolation.less

@@ -1,3 +1,4 @@
+// Parse interpolation tests
 @inputs: input[type=text], input[type=email], input[type=password], textarea;
 
 @{inputs} {
@@ -50,4 +51,4 @@ input {
   .fruit-& {
     content: "Just a test.";
   }
-}
+}

package/tests-unit/parser-property-interp/parser-property-interp.css

@@ -0,0 +1,9 @@
+.test {
+  prop-name: color;
+  my: background;
+  value: width;
+  color: red;
+  border-color-width: 2px;
+  *-z-color: 1px dashed blue;
+  background-color-width: green;
+}

package/tests-unit/parser-property-interp/parser-property-interp.less

@@ -0,0 +1,28 @@
+// Test for ruleProperty parser with ${prop} interpolation (line 2640)
+// This tests complex property names using ${property} interpolation in property NAMES
+// ${prop} uses the VALUE of a plain property (not a variable) as the property name
+// Note: This is different from @{var} which uses variables
+
+.test {
+  // Define properties - their VALUES will be used as property names
+  prop-name: color;
+  my: background;
+  value: width;
+  
+  // Simple ${prop} interpolation in property name (ruleProperty parser line 2640)
+  // ${prop-name} uses the value of prop-name ("color") as the property name
+  // This triggers the branch at line 2640: new(tree.Property)(`$${s.slice(2, -1)}`, ...)
+  ${prop-name}: red;
+  
+  // Multiple interpolations with literal parts
+  // border-${prop-name} becomes "border-color" (since prop-name's value is "color")
+  border-${prop-name}-width: 2px;
+  
+  // Complex property name with ${prop}
+  *-z-${prop-name}: 1px dashed blue;
+  
+  // Multiple ${prop} in same property name
+  // ${my}-${prop-name}-${value} becomes "background-color-width"
+  ${my}-${prop-name}-${value}: green;
+}
+

package/tests-unit/parser-slashed-combinator/parser-slashed-combinator.css

@@ -0,0 +1,9 @@
+.parent /deep/ .child {
+  color: red;
+}
+.container /shadow/ .content {
+  background: blue;
+}
+.wrapper /deep/ .inner /deep/ .deepest {
+  padding: 10px;
+}

package/tests-unit/parser-slashed-combinator/parser-slashed-combinator.less

@@ -0,0 +1,20 @@
+// Test for slashedCombinator parser (lines 1392-1399)
+// This tests /deep/ and /shadow/ combinators
+// NOTE: These combinators are DEPRECATED in CSS and should not be used in new code
+// They were part of the Shadow DOM specification but have been removed
+
+// /deep/ combinator (deprecated)
+.parent /deep/ .child {
+  color: red;
+}
+
+// /shadow/ combinator (deprecated)
+.container /shadow/ .content {
+  background: blue;
+}
+
+// Test with nested selectors
+.wrapper /deep/ .inner /deep/ .deepest {
+  padding: 10px;
+}
+

package/{less/_main → tests-unit/permissive-parse}/permissive-parse.less

@@ -59,3 +59,5 @@
 }
 .test-no-trailing-semicolon2 {--value: foo}
 .test-no-trailing-semicolon3 { --value: foo }
+
+

package/{less/_main → tests-unit/plugin}/plugin.less

@@ -140,3 +140,4 @@ test-atrule("@arbitrary"; "value after ()");
 @plugin (option2) "../../plugin/plugin-set-options-v3";
 @plugin "../../plugin/plugin-set-options-v3";
 @plugin (option3) "../../plugin/plugin-set-options-v3";
+