less 3.9.0 → 3.10.1

package/test/less-bom/mixins-guards-default-func.less

@@ -1,195 +0,0 @@
-
-// basics:
-
-guard-default-basic-1 {
-    .m(1)                   {case:     1}
-    .m(@x) when (default()) {default: @x}
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-}
-
-guard-default-basic-2 {
-    .m(1)                   {case:     1}
-    .m(2)                   {case:     2}
-    .m(3)                   {case:     3}
-    .m(@x) when (default()) {default: @x}
-
-    &-0 {.m(0)}
-    &-2 {.m(2)}
-}
-
-guard-default-basic-3 {
-    .m(@x) when (@x = 1)    {case:     1}
-    .m(2)                   {case:     2}
-    .m(@x) when (@x = 3)    {case:     3}
-    .m(@x) when (default()) {default: @x}
-
-    &-0 {.m(0)}
-    &-2 {.m(2)}
-    &-3 {.m(3)}
-}
-
-guard-default-definition-order {
-    .m(@x) when (default()) {default: @x}
-    .m(@x) when (@x = 1)    {case:     1}
-    .m(2)                   {case:     2}
-    .m(@x) when (@x = 3)    {case:     3}
-
-    &-0 {.m(0)}
-    &-2 {.m(2)}
-    &-2 {.m(3)}
-}
-
-// out of guard:
-
-guard-default-out-of-guard {
-    .m(1)                              {case-1:   1}
-    .m(@x: default()) when (default()) {default: @x}
-
-    &-0 {
-        case-0: default();
-        .m(1);
-        .m(2);
-        case-2: default();
-    }
-    &-1 {.m(default())}
-    &-2 {.m()}
-}
-
-// expressions:
-
-guard-default-expr-not {
-    .m(1)                      {case:     1}
-    .m(@x) when not(default()) {default: @x}
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-}
-
-guard-default-expr-eq {
-    .m(@x) when (@x = true)      {case:    @x}
-    .m(@x) when (@x = false)     {case:    @x}
-    .m(@x) when (@x = default()) {default: @x}
-
-    &-true  {.m(true)}
-    &-false {.m(false)}
-}
-
-guard-default-expr-or {
-    .m(1)                             {case:     1}
-    .m(2)                             {case:     2}
-    .m(@x) when (default()), (@x = 2) {default: @x}
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-    &-3 {.m(3)}
-}
-
-guard-default-expr-and {
-    .m(1)                                {case:     1}
-    .m(2)                                {case:     2}
-    .m(@x) when (default()) and (@x = 3) {default: @x}
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-    &-3 {.m(3)}
-    &-4 {.m(4)}
-}
-
-guard-default-expr-always {
-    .m(1)                                   {case:     1}
-    .m(@x) when (default()), not(default()) {default: @x} // always match
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-}
-
-guard-default-expr-never {
-    .m(1)                                      {case:     1}
-    .m(@x) when (default()) and not(default()) {default: @x} // never match
-
-    &-1 {.m(1)}
-    &-2 {.m(2)}
-}
-
-
-// not conflicting multiple default() uses:
-
-guard-default-multi-1 {
-    .m(0)                   {case:       0}
-    .m(@x) when (default()) {default-1: @x}
-    .m(2)  when (default()) {default-2: @x}
-
-    &-0 {.m(0)}
-    &-1 {.m(1)}
-}
-
-guard-default-multi-2 {
-    .m(1, @x)   when (default()) {default-1: @x}
-    .m(2, @x)   when (default()) {default-2: @x}
-    .m(@x, yes) when (default()) {default-3: @x}
-
-    &-1 {.m(1, no)}
-    &-2 {.m(2, no)}
-    &-3 {.m(3, yes)}
-}
-
-guard-default-multi-3 {
-    .m(red)                                    {case-1: darkred}
-    .m(blue)                                   {case-2: darkblue}
-    .m(@x) when (iscolor(@x)) and (default())  {default-color: @x}
-    .m('foo')                                  {case-1: I am 'foo'}
-    .m('bar')                                  {case-2: I am 'bar'}
-    .m(@x) when (isstring(@x)) and (default()) {default-string: I am @x}
-
-    &-blue  {.m(blue)}
-    &-green {.m(green)}
-    &-foo   {.m('foo')}
-    &-baz   {.m('baz')}
-}
-
-guard-default-multi-4 {
-    .m(@x) when (default()), not(default())    {always: @x}
-    .m(@x) when (default()) and not(default()) {never:  @x}
-    .m(2)                                      {case:    2}
-
-    .m(1);
-    .m(2);
-}
-
-guard-default-not-ambiguos-2 {
-    .m(@x)                     {case:         1}
-    .m(@x) when (default())    {default:     @x}
-    .m(@x) when not(default()) {not-default: @x}
-
-    .m(2);
-}
-
-guard-default-not-ambiguos-3 {
-    .m(@x)                     {case:           1}
-    .m(@x) when not(default()) {not-default-1: @x}
-    .m(@x) when not(default()) {not-default-2: @x}
-
-    .m(2);
-}
-
-// default & scope
-
-guard-default-scopes {
-    .s1() {.m(@v)                  {1: no condition}}
-    .s2() {.m(@v) when (@v)        {2: when true}}
-    .s3() {.m(@v) when (default()) {3: when default}}
-
-    &-3 {
-        .s2();
-        .s3();
-        .m(false);
-    }
-
-    &-1 {
-        .s1();
-        .s3();
-        .m(false);
-    }
-}

package/test/less-bom/mixins-guards.less

@@ -1,358 +0,0 @@
-
-// Stacking, functions..
-
-.light (@a) when (lightness(@a) > 50%) {
-  color: white;
-}
-.light (@a) when (lightness(@a) < 50%) {
-  color: black;
-}
-.light (@a) {
-  margin: 1px;
-}
-
-.light1 { .light(#ddd) }
-.light2 { .light(#444) }
-
-// Arguments against each other
-
-.max (@a, @b) when (@a > @b) {
-  width: @a;
-}
-.max (@a, @b) when (@a < @b) {
-  width: @b;
-}
-
-.max1 { .max(3, 6) }
-.max2 { .max(8, 1) }
-
-// Globals inside guards
-
-@g: auto;
-
-.glob (@a) when (@a = @g) {
-  margin: @a @g;
-}
-.glob1 { .glob(auto) }
-
-// Other operators
-
-.ops (@a) when (@a >= 0) {
-  height: gt-or-eq;
-}
-.ops (@a) when (@a =< 0) {
-  height: lt-or-eq;
-}
-.ops (@a) when (@a <= 0) {
-  height: lt-or-eq-alias;
-}
-.ops (@a) when not(@a = 0) {
-  height: not-eq;
-}
-.ops1 { .ops(0) }
-.ops2 { .ops(1) }
-.ops3 { .ops(-1) }
-
-// Scope and default values
-
-@a: auto;
-
-.default (@a: inherit) when (@a = inherit) {
-  content: default;
-}
-.default1 { .default }
-
-// true & false keywords
-.test (@a) when (@a) {
-    content: "true.";
-}
-.test (@a) when not (@a) {
-    content: "false.";
-}
-
-.test1 { .test(true) }
-.test2 { .test(false) }
-.test3 { .test(1) }
-.test4 { .test(boo) }
-.test5 { .test("true") }
-
-// Boolean expressions
-
-.bool () when (true) and (false)                             { content: true and false } // FALSE
-.bool () when (true) and (true)                              { content: true and true } // TRUE
-.bool () when (true)                                         { content: true } // TRUE
-.bool () when (false) and (false)                            { content: true } // FALSE
-.bool () when (false), (true)                                { content: false, true } // TRUE
-.bool () when (false) and (true) and (true),  (true)         { content: false and true and true, true } // TRUE
-.bool () when (true)  and (true) and (false), (false)        { content: true and true and false, false } // FALSE
-.bool () when (false), (true) and (true)                     { content: false, true and true } // TRUE
-.bool () when (false), (false), (true)                       { content: false, false, true } // TRUE
-.bool () when (false), (false) and (true), (false)           { content: false, false and true, false } // FALSE
-.bool () when (false), (true) and (true) and (true), (false) { content: false, true and true and true, false } // TRUE
-.bool () when not (false)                                    { content: not false }
-.bool () when not (true) and not (false)                     { content: not true and not false }
-.bool () when not (true) and not (true)                      { content: not true and not true }
-.bool () when not (false) and (false), not (false)           { content: not false and false, not false }
-
-.bool1 { .bool }
-
-.equality-unit-test(@num) when (@num = 1%) {
-  test: fail;
-}
-.equality-unit-test(@num) when (@num = 2) {
-  test: pass;
-}
-.equality-units {
-  .equality-unit-test(1px);
-  .equality-unit-test(2px);
-}
-
-.colorguard(@col) when (@col = red)                         { content: is @col; }
-.colorguard(@col) when not (blue = @col)                    { content: is not blue its @col; }
-.colorguard(@col)                                           {}
-.colorguardtest {
-    .colorguard(red);
-    .colorguard(blue);
-    .colorguard(purple);
-}
-
-.stringguard(@str) when (@str = "theme1")					{ content: @str is "theme1"; }
-.stringguard(@str) when not ("theme2" = @str)				{ content: @str is not "theme2"; }
-.stringguard(@str) when (@str = 'theme1')					{ content: @str is 'theme1'; }
-.stringguard(@str) when not ('theme2' = @str)				{ content: @str is not 'theme2'; }
-.stringguard(@str) when (~"theme1" = @str)					{ content: @str is theme1; }
-.stringguard(@str)                                          {}
-.stringguardtest {
-    .stringguard("theme1");
-    .stringguard("theme2");
-    .stringguard('theme1');
-    .stringguard('theme2');
-    .stringguard(theme1);
-}
-
-.generic(@a, @b) {/**/}
-.generic(@a, @b) when (@a = @b) {content: @a is equal to @b}
-.generic(@a, @b) when (@b = @a) {content: @b is equal to @a too}
-.generic(@a, @b) when (@a < @b) {content: @a is less than @b}
-.generic(@a, @b) when (@b < @a) {content: @b is less than @a too}
-.generic(@a, @b) when (@a > @b) {content: @a is greater than @b}
-.generic(@a, @b) when (@b > @a) {content: @b is greater than @a too}
-.generic(@a, @b) when not(@a = @b) {content: @a is not equal to @b}
-.generic(@a, @b) when not(@b = @a) {content: @b is not equal to @a too}
-
-.variouse-types-comparison {
-    .generic(true, false);
-    .generic(1, true);
-    .generic(2, 2px);
-    .generic(3, ~"3");
-    .generic(5, ~"4");
-    .generic(abc, ~"abc");
-    .generic(abc, "abc");
-    .generic('abc', "abd");
-    .generic(6, e("6"));
-    .generic(9, 8);
-    .generic(a, b);
-    .generic(1 2, 3);
-}
-
-.list-comparison {
-    .generic(a b c, a b c);
-    .generic(a b c, a b d);
-    .generic(a, b, c; a, b, c);
-    .generic(a, b, c; a, b, d);
-    .generic(1 2px 300ms, 1em 2 .3s);
-    
-    @space-list: 1 2 3;
-    @comma-list: 1, 2, 3;
-    @compound: @space-list @comma-list;
-    
-    .generic(@space-list, @comma-list);
-    .generic(@comma-list, ~"1, 2, 3");
-    .generic(@compound, @space-list @comma-list);
-    .generic(@compound, @comma-list @space-list);
-    .generic(@compound 4, ~"1 2 3 1, 2, 3 4");
-}
-
-.mixin(...) {
-  catch:all;
-}
-.mixin(@var) when (@var=4) {
-  declare: 4;
-}
-.mixin(@var) when (@var=4px) {
-  declare: 4px;
-}
-#tryNumberPx {
-  .mixin(4px);
-}
-
-.lock-mixin(@a) {
- .inner-locked-mixin(@x: @a) when (@a = 1) {
-    a: @a;
-    x: @x;
-  }
-}
-.call-lock-mixin {
-  .lock-mixin(1);
-  .call-inner-lock-mixin {
-    .inner-locked-mixin();
-  }
-}
-.bug-100cm-1m(@a) when (@a = 1) {
-  .failed {
-    one-hundred: not-equal-to-1;
-  }
-}
-.bug-100cm-1m(100cm);
-
-#ns {
-    .mixin-for-root-usage(@a) when (@a > 0) {
-        .mixin-generated-class {
-            a: @a;
-        }
-    }
-}
-
-#ns > .mixin-for-root-usage(1);
-
-@namespaceGuard: 1;
-#guarded when (@namespaceGuard>0) {
-  #deeper {
-    .mixin() {
-      guarded: namespace;
-    }
-  }
-}
-#guarded() when (@namespaceGuard>0) {
-  #deeper {
-    .mixin() {
-      silent: namespace;
-    }
-  }
-}
-#guarded(@variable) when (@namespaceGuard>0) {
-  #deeper {
-    .mixin() {
-      should: not match because namespace argument;
-    }
-  }
-}
-#guarded(@variable: default) when (@namespaceGuard>0) {
-  #deeper {
-    .mixin() {
-      guarded: with default;
-    }
-  }
-}
-#guarded when (@namespaceGuard<0) {
-  #deeper {
-    .mixin() {
-      should: not match because namespace guard;
-    }
-  }
-}
-#guarded-caller {
-  #guarded > #deeper > .mixin();
-}
-#top {
-  #deeper when (@namespaceGuard<0) {
-    .mixin(@a) {
-      should: not match because namespace guard;
-    }
-  }
-  #deeper() when (@namespaceGuard>0) {
-    .mixin(@a) {
-      should: match @a;
-    }
-  }
-}
-#guarded-deeper {
-  #top > #deeper > .mixin(1);
-}
-
-// namespaced & guarded mixin in root
-// outputs nothing but should pass:
-
-@guarded-mixin-for-root: true;
-#ns {
-    .guarded-mixin-for-root() when (@guarded-mixin-for-root) {}
-}
-#ns > .guarded-mixin-for-root();
-// various combinations of nested or, and, parenthesis and negation
-.parenthesisNot(@value) when ((((@value)))) {
-  parenthesisNot: just-value;
-}
-.parenthesisNot(@value) when (((not(@value)))) {
-  parenthesisNot: negated once inside;
-}
-.parenthesisNot(@value) when not((((@value)))) {
-  parenthesisNot: negated once outside;
-}
-.parenthesisNot(@value) when ((not((@value)))) {
-  parenthesisNot: negated once middle;
-}
-.parenthesisNot(@value) when not(((not(@value)))) {
-  parenthesisNot: negated twice 1;
-}
-.parenthesisNot(@value) when (not((not(@value)))) {
-  parenthesisNot: negated twice 2;
-}
-.parenthesisNot(@value) when ((not(not(@value)))) {
-  parenthesisNot: negated twice 3;
-}
-.parenthesisNot (...) when (default()) {
-  parenthesisNot: none matched;
-}
-
-#parenthesisNot-true {
-  .parenthesisNot(true);
-}
-#parenthesisNot-false {
-  .parenthesisNot(false);
-}
-
-.orderOfEvaluation(@a1, @a2, @a3) when ((@a1) and (@a2) or (@a3)) {
-  no-parenthesis: evaluated true 1a;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when ((@a3) or (@a1) and (@a2)) {
-  no-parenthesis: evaluated true 1b;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when ((@a1) and ((@a2) or (@a3))) {
-  no-parenthesis: evaluated true 1c;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when (@a3), (@a1) and (@a2) {
-  no-parenthesis: evaluated true 1d;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when (((@a3) or (@a1)) and (@a2)) {
-  no-parenthesis: evaluated true 1e;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when ((@a1) and (@a2) or not (@a3)) {
-  no-parenthesis: evaluated true 2a;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when (not (@a3) or (@a1) and (@a2)) {
-  no-parenthesis: evaluated true 2b;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when not (@a3), (@a1) and (@a2) {
-  no-parenthesis: evaluated true 2c;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when (not (@a1) and (@a2) or (@a3)) {
-  no-parenthesis: evaluated true 3;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when ((((@a1) and (@a2) or (@a3)))) {
-  no-parenthesis: evaluated true 4;
-}
-.orderOfEvaluation(@a1, @a2, @a3) when (((@a1) and (@a2)) or (@a3)) {
-  with-parenthesis: evaluated true;
-}
-.orderOfEvaluation(...) when (default()) {
-  orderOfEvaluation: evaluated false;
-}
-#orderOfEvaluation-false-false-true {
-  .orderOfEvaluation(false, false, true);
-}
-#orderOfEvaluation-false-false-false {
-  .orderOfEvaluation(false, false, false);
-}
-#orderOfEvaluation-true-true-false {
-  .orderOfEvaluation(true, true, false);
-}

package/test/less-bom/mixins-important.less

@@ -1,53 +0,0 @@
-.submixin(@a) {
-  border-width: @a;
-}
-.mixin (9) {
-  border: 9 !important;
-}
-.mixin (@a: 0) {
-  border: @a;
-  boxer: @a;
-  .inner {
-    test: @a;
-  }
-  // comment
-  .submixin(@a);
-}
-
-.class {
-  .mixin(1);
-  .mixin(2) !important;
-  .mixin(3);
-  .mixin(4) !important;
-  .mixin(5);
-  .mixin !important;
-  .mixin(9);
-}
-.size(@aaa: auto) {
-  .set-width(@aaa) {
-    width: @aaa;
-  }
-  .set-width(@aaa);
-}
-.when-calling-nested-issue-2394 {
-  .size() !important;
-}
-.when-calling-nested-with-param-issue-2394 {
-  .size(10px) !important;
-}
-.testMixin-2421 () {
-    .topCheck-2421 () {
-        .nestedCheck-2421() {
-            margin: 5px;
-        }
-        .nestedCheck-2421();
-    }
-    .topCheck-2421();
-}
-.class1-2421 {
-    .testMixin-2421() !important;
-}
-.class2-2421 {
-    .testMixin-2421();
-}
-

package/test/less-bom/mixins-interpolated.less

@@ -1,75 +0,0 @@
-
-@a0: 123;
-@a1: foo;
-@a2: ~".foo";
-@a4: ~"#foo";
-
-.@{a0} {
-    a: 0;
-}
-
-.@{a1} {
-    a: 1;
-}
-
-@{a2} {
-    a: 2;
-}
-
-#@{a1} {
-    a: 3;
-}
-
-@{a4} {
-    a: 4;
-}
-
-mi-test-a {
-    .123;
-    .foo;
-    #foo;
-}
-
-.b .bb {
-    &.@{a1}-xxx .yyy-@{a1}@{a4} {
-        & @{a2}.bbb {
-            b: 1;
-        }
-    }
-}
-
-mi-test-b {
-    .b.bb.foo-xxx.yyy-foo#foo.foo.bbb;
-}
-
-@c1: @a1;
-@c2: bar;
-@c3: baz;
-
-#@{c1}-foo {
-    > .@{c2} {
-        .@{c3} {
-            c: c;
-        }
-    }
-}
-
-mi-test-c {
-    &-1 {#foo-foo;}
-    &-2 {#foo-foo > .bar;}
-    &-3 {#foo-foo > .bar.baz;}
-}
-
-.Person(@name, @gender_) {
-    .@{name} {
-        @gender: @gender_;
-        .sayGender() {
-            gender: @gender;
-        }
-    }
-}
-
-mi-test-d {
-    .Person(person, "Male");
-    .person.sayGender();
-}

package/test/less-bom/mixins-named-args.less

@@ -1,36 +0,0 @@
-.mixin (@a: 1px, @b: 50%) {
-  width: (@a * 5);
-  height: (@b - 1%);
-  args: @arguments;
-}
-.mixin (@a: 1px, @b: 50%) when (@b > 75%){
-  text-align: center;
-}
-
-.named-arg {
-  color: blue;
-  .mixin(@b: 100%);
-}
-
-.class {
-  @var: 20%;
-  .mixin(@b: @var);
-}
-
-.all-args-wrong-args {
-  .mixin(@b: 10%, @a: 2px);
-}
-
-.mixin2 (@a: 1px, @b: 50%, @c: 50) {
-  width: (@a * 5);
-  height: (@b - 1%);
-  color: (#000000 + @c);
-}
-
-.named-args2 {
-  .mixin2(3px, @c: 100);
-}
-
-.named-args3 {
-  .mixin2(@b: 30%, @c: #123456);
-}