less-execjs 2.6.0.3

data/lib/less/js/less/test/less/merge.less

@@ -0,0 +1,78 @@
+.first-transform() {
+  transform+: rotate(90deg), skew(30deg);
+}
+.second-transform() {
+  transform+: scale(2,4);
+}
+.third-transform() {
+  transform: scaleX(45deg);
+}
+.fourth-transform() {
+  transform+: scaleX(45deg);
+}
+.fifth-transform() {
+  transform+: scale(2,4) !important;
+}
+.first-background() {
+  background+: url(data://img1.png);
+}
+.second-background() {
+  background+: url(data://img2.png);
+}
+
+.test1 {
+  // Can merge values
+  .first-transform();
+  .second-transform();
+}
+.test2 {
+  // Wont merge values without +: merge directive, for backwards compatibility with css
+  .first-transform();
+  .third-transform();
+}
+.test3 {
+  // Wont merge values from two sources with different properties
+  .fourth-transform();
+  .first-background();
+}
+.test4 {
+  // Wont merge values from sources that merked as !important, for backwards compatibility with css
+  .first-transform();
+  .fifth-transform();
+}
+.test5 {
+  // Wont merge values from mixins that merked as !important, for backwards compatibility with css
+  .first-transform();
+  .second-transform() !important;
+}
+.test6 {
+  // Ignores !merge if no peers found
+  .second-transform();
+}
+
+.test-interleaved {
+    transform+:  t1;
+    background+: b1;
+    transform+:  t2;
+    background+: b2, b3;
+    transform+:  t3;
+}
+
+.test-spaced {
+    transform+_:  t1;
+    background+_: b1;
+    transform+_:  t2;
+    background+_: b2, b3;
+    transform+_:  t3;
+}
+
+.test-interleaved-with-spaced {
+    transform+_:  t1s;
+    transform+:   t2;
+    background+:  b1;
+    transform+_:  t3s;
+    transform+:   t4 t5s;
+    background+_: b2s, b3;
+    transform+_:  t6s;
+    background+:  b4;
+}

data/lib/less/js/less/test/less/mixins-args.less

@@ -0,0 +1,263 @@
+.mixin (@a: 1px, @b: 50%) {
+  width: (@a * 5);
+  height: (@b - 1%);
+}
+
+.mixina (@style, @width, @color: black) {
+    border: @width @style @color;
+}
+
+.mixiny
+(@a: 0, @b: 0) {
+  margin: @a;
+  padding: @b;
+}
+
+.hidden() {
+  color: transparent; // asd
+}
+
+#hidden {
+  .hidden;
+}
+
+#hidden1 {
+  .hidden();
+}
+
+.two-args {
+  color: blue;
+  .mixin(2px, 100%);
+  .mixina(dotted, 2px);
+}
+
+.one-arg {
+  .mixin(3px);
+}
+
+.no-parens {
+  .mixin;
+}
+
+.no-args {
+  .mixin();
+}
+
+.var-args {
+  @var: 9;
+  .mixin(@var, (@var * 2));
+}
+
+.multi-mix {
+  .mixin(2px, 30%);
+  .mixiny(4, 5);
+}
+
+.maxa(@arg1: 10, @arg2: #f00) {
+  padding: (@arg1 * 2px);
+  color: @arg2;
+}
+
+body {
+  .maxa(15);
+}
+
+@glob: 5;
+.global-mixin(@a:2) {
+  width: (@glob + @a);
+}
+
+.scope-mix {
+  .global-mixin(3);
+}
+
+.nested-ruleset (@width: 200px) {
+    width: @width;
+    .column { margin: @width; }
+}
+.content {
+    .nested-ruleset(600px);
+}
+
+//
+
+.same-var-name2(@radius) {
+  radius: @radius;
+}
+.same-var-name(@radius) {
+  .same-var-name2(@radius);
+}
+#same-var-name {
+  .same-var-name(5px);
+}
+
+//
+
+.var-inside () {
+    @var: 10px;
+    width: @var;
+}
+#var-inside { .var-inside; }
+
+.mixin-arguments (@width: 0px, ...) {
+    border: @arguments;
+    width: @width;
+}
+
+.arguments {
+    .mixin-arguments(1px, solid, black);
+}
+.arguments2 {
+    .mixin-arguments();
+}
+.arguments3 {
+    .mixin-arguments;
+}
+
+.mixin-arguments2 (@width, @rest...) {
+    border: @arguments;
+    rest: @rest;
+    width: @width;
+}
+.arguments4 {
+    .mixin-arguments2(0, 1, 2, 3, 4);
+}
+
+// Edge cases
+
+.edge-case {
+    .mixin-arguments("{");
+}
+
+// Division vs. Literal Slash
+.border-radius(@r: 2px/5px) {
+  border-radius: @r;
+}
+.slash-vs-math {
+  .border-radius();
+  .border-radius(5px/10px);
+  .border-radius((3px * 2));
+}
+// semi-colon vs comma for delimiting
+
+.mixin-takes-one(@a) {
+    one: @a;
+}
+
+.mixin-takes-two(@a; @b) {
+    one: @a;
+    two: @b;
+}
+
+.comma-vs-semi-colon {
+    .mixin-takes-two(@a : a; @b : b, c);
+    .mixin-takes-two(@a : d, e; @b : f);
+    .mixin-takes-one(@a: g);
+    .mixin-takes-one(@a : h;);
+    .mixin-takes-one(i);
+    .mixin-takes-one(j;);
+    .mixin-takes-two(k, l);
+    .mixin-takes-one(m, n;);
+    .mixin-takes-two(o, p; q);
+    .mixin-takes-two(r, s; t;);
+}
+
+.mixin-conflict(@a:defA, @b:defB, @c:defC) {
+  three: @a, @b, @c;
+}
+
+.mixin-conflict(@a:defA, @b:defB, @c:defC, @d:defD) {
+  four: @a, @b, @c, @d;
+}
+
+#named-conflict {
+  .mixin-conflict(11, 12, 13, @a:a);
+  .mixin-conflict(@a:a, 21, 22, 23);
+}
+@a: 3px;
+.mixin-default-arg(@a: 1px, @b: @a, @c: @b) {
+  defaults: 1px 1px 1px;
+  defaults: 2px 2px 2px;
+}
+
+.test-mixin-default-arg {
+  .mixin-default-arg();
+  .mixin-default-arg(2px);
+}
+
+.mixin-comma-default1(@color; @padding; @margin: 2, 2, 2, 2) {
+  margin: @margin;
+}
+.selector {
+  .mixin-comma-default1(#33acfe; 4);
+}
+.mixin-comma-default2(@margin: 2, 2, 2, 2;) {
+  margin: @margin;
+}
+.selector2 {
+  .mixin-comma-default2();
+}
+.mixin-comma-default3(@margin: 2, 2, 2, 2) {
+  margin: @margin;
+}
+.selector3 {
+  .mixin-comma-default3(4,2,2,2);
+}
+
+.test-calling-one-arg-mixin(@a) {
+}
+
+.test-calling-one-arg-mixin(@a, @b, @rest...) {
+}
+
+div {
+  .test-calling-one-arg-mixin(1);
+}
+
+mixins-args-expand-op- {
+  @x: 1, 2, 3;
+  @y: 4  5  6;
+
+  &1 {.m3(@x...)}
+  &2 {.m3(@y...)}
+  &3 {.wr(a, b, c)}
+  &4 {.wr(a; b; c, d)}
+  &5 {.wr(@x...)}
+  &6 {.m4(0; @x...)}
+  &7 {.m4(@x..., @a: 0)}
+  &8 {.m4(@b: 1.5; @x...)}
+  &9 {.aa(@y, @x..., and again, @y...)}
+
+  .m3(@a, @b, @c) {
+    m3: @a, @b, @c;
+  }
+
+  .m4(@a, @b, @c, @d) {
+    m4: @a, @b, @c, @d;
+  }
+
+  .wr(@a...) {
+    &a {.m3(@a...)}
+    &b {.m4(0, @a...)}
+    &c {.m4(@a..., 4)}
+  }
+
+  .aa(@a...) {
+    aa: @a;
+    a4: extract(@a, 5);
+    a8: extract(@a, 8);
+  }
+}
+#test-mixin-matching-when-default-2645 {
+  .mixin(@height) {
+    height: @height;
+  }
+
+  .mixin(@width, @height: 10px) {
+    width: @width;
+
+    .mixin(@height: @height);
+  }
+
+  .mixin(@height: 20px);
+}

data/lib/less/js/less/test/less/mixins-closure.less

@@ -0,0 +1,26 @@
+.scope {
+    @var: 99px;
+    .mixin () {
+        width: @var;
+    }
+}
+
+.class {
+    .scope > .mixin;
+}
+
+.overwrite {
+    @var: 0px;
+    .scope > .mixin;
+}
+
+.nested {
+    @var: 5px;
+    .mixin () {
+        width: @var;
+    }
+    .class {
+        @var: 10px;
+       .mixin;
+    }
+}

data/lib/less/js/less/test/less/mixins-guards-default-func.less

@@ -0,0 +1,195 @@
+
+// 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);
+    }
+}