@quenk/wml 2.13.10 → 2.14.0

package/lib/parse/index.d.ts

@@ -1,6 +1,5 @@
-/// <reference path="generated.d.ts" />
-import * as nodes from './ast';
-import { Except } from '@quenk/noni/lib/control/error';
+import * as nodes from "./ast";
+import { Except } from "@quenk/noni/lib/control/error";
 /**
  * parse a string containing WML returning the resulting AST.
  */

package/lib/parse/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AAAA,uCAAuC;;;AAEvC,sCAAsC;AACtC,+BAA+B;AAE/B,yDAAgE;AAEhE;;GAEG;AACI,MAAM,KAAK,GAAG,CAAC,GAAW,EAAE,MAAW,KAAK,EAAwB,EAAE,CACzE,IAAA,eAAO,EAAC,GAAG,EAAE;IAET,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAE3B,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAEpC,CAAC,CAAC,CAAC;AAPM,QAAA,KAAK,SAOX"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";AAAA,uCAAuC;;;AAEvC,sCAAsC;AACtC,+BAA+B;AAE/B,yDAAgE;AAEhE;;GAEG;AACI,MAAM,KAAK,GAAG,CAAC,GAAW,EAAE,MAAW,KAAK,EAAwB,EAAE,CAC3E,IAAA,eAAO,EAAC,GAAG,EAAE;IACX,MAAM,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC;IAE3B,OAAO,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;AAClC,CAAC,CAAC,CAAC;AALQ,QAAA,KAAK,SAKb"}

package/lib/parse/index.ts

@@ -1,18 +1,16 @@
 /// <reference path='generated.d.ts' />
 
-import * as parser from './generated';
-import * as nodes from './ast';
+import * as parser from "./generated";
+import * as nodes from "./ast";
 
-import { Except, attempt } from '@quenk/noni/lib/control/error';
+import { Except, attempt } from "@quenk/noni/lib/control/error";
 
 /**
  * parse a string containing WML returning the resulting AST.
  */
 export const parse = (str: string, ast: any = nodes): Except<nodes.Module> =>
-    attempt(() => {
+  attempt(() => {
+    parser.parser.yy = { ast };
 
-        parser.parser.yy = { ast };
-
-        return parser.parser.parse(str);
-
-    });
+    return parser.parser.parse(str);
+  });

package/lib/parse/test.js

@@ -2,105 +2,105 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tests = void 0;
 exports.tests = {
-    'should parse qualified import': {
-        input: `{% import * as lib from "path/to/libs" %}`
+    "should parse qualified import": {
+        input: `{% import * as lib from "path/to/libs" %}`,
     },
-    'should parse named import': {
-        input: `{% import (B) from "path/to/a/b" %}`
+    "should parse named import": {
+        input: `{% import (B) from "path/to/a/b" %}`,
     },
-    'should detect exact duplicate imports': {
-        input: `{% import (A) from "b" %} {% import (A) from "b" %}`
+    "should detect exact duplicate imports": {
+        input: `{% import (A) from "b" %} {% import (A) from "b" %}`,
     },
-    'should parse a self closing tag': {
-        input: '<simple/>'
+    "should parse a self closing tag": {
+        input: "<simple/>",
     },
-    'should parse a self closing tag with attributes 0': {
+    "should parse a self closing tag with attributes 0": {
         input: '<user name="xyaa aaz" position={{4|x(20)}} wml:val="test"/>',
     },
-    'should parse a self closing tag with attributes 1': {
-        input: '<user app:enabled id=24 />',
+    "should parse a self closing tag with attributes 1": {
+        input: "<user app:enabled id=24 />",
     },
-    'should parse a self closing tag with attributes 2': {
+    "should parse a self closing tag with attributes 2": {
         input: '<user name="xyaa aaz" id="24" align="left"/>',
     },
-    'should parse a parent tag': {
-        input: '<panel>  \n\n\n\n\n\n\n\n\n  </panel>'
+    "should parse a parent tag": {
+        input: "<panel>  \n\n\n\n\n\n\n\n\n  </panel>",
     },
-    'should parse a parent tag with attributes': {
-        input: '<panel type="default" size="40" align="left"> </panel>'
+    "should parse a parent tag with attributes": {
+        input: '<panel type="default" size="40" align="left"> </panel>',
     },
-    'should parse parent tags with mixed children': {
-        input: '<panel> This is my offsprings.<a>Link</a>Hey now! <Input/></panel>'
+    "should parse parent tags with mixed children": {
+        input: "<panel> This is my offsprings.<a>Link</a>Hey now! <Input/></panel>",
     },
-    'should parse parent tags with tag children (L1)': {
-        input: '<panel><a></a></panel>'
+    "should parse parent tags with tag children (L1)": {
+        input: "<panel><a></a></panel>",
     },
-    'should parse parent tags with tag children (L2)': {
+    "should parse parent tags with tag children (L2)": {
         input: '<panel><a href="link" onclick={{@someting.invoke()}}>' +
-            'Click Here</a><table/></panel>'
+            "Click Here</a><table/></panel>",
     },
-    'should parse parent tags with tag children (L3)': {
+    "should parse parent tags with tag children (L3)": {
         input: '<panel><a href="link">Click Here</a><table/>' +
-            '<panel c="22"></panel></panel>'
+            '<panel c="22"></panel></panel>',
     },
-    'should do it all together now': {
+    "should do it all together now": {
         input: '<modal name="mymodal" x="1" y="2">' +
-            '<modal-header>My Modal</modal-header>' +
-            '<modal-body>' +
-            'Creativxity is inhibxited by greed and corruption.' +
-            '<vote-button/>' +
-            '<vote-count source={{@}}/> Votes' +
+            "<modal-header>My Modal</modal-header>" +
+            "<modal-body>" +
+            "Creativxity is inhibxited by greed and corruption." +
+            "<vote-button/>" +
+            "<vote-count source={{@}}/> Votes" +
             '<textarea wml:id="ta" disabled size=32 onchange={{@setText}}>' +
-            ' Various text' +
-            '</textarea>' +
-            '</modal-body>' +
-            '</modal>'
-    },
-    'should parse for in statements': {
-        input: '<root>' +
-            '{% for value,key in [] %}' +
-            '<stem>{{value}}</stem>' +
-            '{% endfor %}' +
-            '</root>'
-    },
-    'should parse for of statements': {
-        input: '<root>' +
-            '{% for value,key of {} %}' +
-            '<stem>{{key}} ~ {{value}}</stem>' +
-            '{% endfor %}' +
-            '</root>'
-    },
-    'should parse for from statements': {
+            " Various text" +
+            "</textarea>" +
+            "</modal-body>" +
+            "</modal>",
+    },
+    "should parse for in statements": {
+        input: "<root>" +
+            "{% for value,key in [] %}" +
+            "<stem>{{value}}</stem>" +
+            "{% endfor %}" +
+            "</root>",
+    },
+    "should parse for of statements": {
+        input: "<root>" +
+            "{% for value,key of {} %}" +
+            "<stem>{{key}} ~ {{value}}</stem>" +
+            "{% endfor %}" +
+            "</root>",
+    },
+    "should parse for from statements": {
         input: `
               <root>
                 {% for value=1 to 30 %}
                   <b>{{value}}</b>
                 {% endfor %}
               </root>
-              `
+              `,
     },
-    'should parse if then expressions': {
-        input: '<Html id={{@id}}>{{ if @check() then a else b }}</Html>'
+    "should parse if then expressions": {
+        input: "<Html id={{@id}}>{{ if @check() then a else b }}</Html>",
     },
-    'should parse function expressions': {
-        input: '<button onclick={{e -> call(e)}}/>'
+    "should parse function expressions": {
+        input: "<button onclick={{e -> call(e)}}/>",
     },
-    'should parse function expressions (no args)': {
-        input: '<button onclick={{ -> call()}}/>'
+    "should parse function expressions (no args)": {
+        input: "<button onclick={{ -> call()}}/>",
     },
-    'should parse calls': {
-        input: '<tr>{% for x,i in y %} {{ f(x, i) }} {% endfor %} </tr>'
+    "should parse calls": {
+        input: "<tr>{% for x,i in y %} {{ f(x, i) }} {% endfor %} </tr>",
     },
-    'should parse negative numbers': {
-        input: '<tag n={{ ( -0.5 + 3) }} m={{(4 + -2)}} g={{ (10 --5) }}/>'
+    "should parse negative numbers": {
+        input: "<tag n={{ ( -0.5 + 3) }} m={{(4 + -2)}} g={{ (10 --5) }}/>",
     },
-    'should allow filter chaining': {
-        input: '<p>{{ @value | f1 | f2(2) | f3(@value) }}</p>'
+    "should allow filter chaining": {
+        input: "<p>{{ @value | f1 | f2(2) | f3(@value) }}</p>",
     },
-    'should parse if else statements': {
-        input: '<Tag>{% if value %}<text>Text</text>{% else %}<text>else</text>{% endif %}</Tag>'
+    "should parse if else statements": {
+        input: "<Tag>{% if value %}<text>Text</text>{% else %}<text>else</text>{% endif %}</Tag>",
     },
-    'should parse if else if statements': {
+    "should parse if else if statements": {
         input: `
         <Tag>
           {% if value %}
@@ -110,93 +110,95 @@ exports.tests = {
           {% else %}
             no
           {% endif %}
-        </Tag>`
+        </Tag>`,
     },
-    'should parse short fun statements': {
-        input: '{% fun vue () = <View/> %}'
+    "should parse short fun statements": {
+        input: "{% fun vue () = <View/> %}",
     },
-    'should parse short fun statements with arguments': {
-        input: '{% fun vue (a:String, b:String, c:String) = ' +
-            '<View a={{a}} b={{b}} c={{c}}/> %}'
+    "should parse short fun statements with arguments": {
+        input: "{% fun vue (a:String, b:String, c:String) = " +
+            "<View a={{a}} b={{b}} c={{c}}/> %}",
     },
-    'should parse short fun statements with type parameters': {
-        input: '{% fun vue [A,B:C,C] (a:A, b:B) = ' +
-            '{{ (a + b) + c }} %}'
+    "should parse short fun statements with type parameters": {
+        input: "{% fun vue [A,B:C,C] (a:A, b:B) = " + "{{ (a + b) + c }} %}",
     },
-    'should parse extended fun statements': {
-        input: '{% fun vue () %} <View/> {% endfun %}'
+    "should parse extended fun statements": {
+        input: "{% fun vue () %} <View/> {% endfun %}",
     },
-    'should parse extended fun statements with arguments': {
-        input: '{% fun vue (a:String, b:String, c:String) %}' +
-            '<View a={{a}} b={{b}} c={{c}}/> {% endfun %}'
+    "should parse extended fun statements with arguments": {
+        input: "{% fun vue (a:String, b:String, c:String) %}" +
+            "<View a={{a}} b={{b}} c={{c}}/> {% endfun %}",
     },
-    'should parse extended fun statements with type parameters': {
-        input: '{% fun vue [A,B:C,C] (a:A, b:B) %} {{ ((a + b) + c) }} {% endfun %}'
+    "should parse extended fun statements with type parameters": {
+        input: "{% fun vue [A,B:C,C] (a:A, b:B) %} {{ ((a + b) + c) }} {% endfun %}",
     },
-    'should parse binary expressions': {
-        input: '<p>{{(Styles.A  + Styles.B)}}</p>'
+    "should parse binary expressions": {
+        input: "<p>{{(Styles.A  + Styles.B)}}</p>",
     },
-    'should parse complicated expressions': {
-        input: '<div class={{((Styles.A + " ") + Style.B)}}/>'
+    "should parse complicated expressions": {
+        input: '<div class={{((Styles.A + " ") + Style.B)}}/>',
     },
-    'should allow for statement as child of fun': {
-        input: '{% fun sven () %} {% for a in b %} {{b}} {% endfor %} {% endfun %}'
+    "should allow for statement as child of fun": {
+        input: "{% fun sven () %} {% for a in b %} {{b}} {% endfor %} {% endfun %}",
     },
-    'should allow if statement as child of  fun': {
-        input: '{% fun ate (o:Object) %} {% if a %} {{a}} {% else %} {{a}} ' +
-            '{% endif %} {% endfun %}'
+    "should allow if statement as child of  fun": {
+        input: "{% fun ate (o:Object) %} {% if a %} {{a}} {% else %} {{a}} " +
+            "{% endif %} {% endfun %}",
     },
-    'should allow for booleans in interpolations': {
-        input: '<bool active={{true}}>{{if fun() then false else true}}</bool>'
+    "should allow for booleans in interpolations": {
+        input: "<bool active={{true}}>{{if fun() then false else true}}</bool>",
     },
-    'should allow calls on expressions': {
-        input: '<div>{{(content() || bar)(foo)}}</div>'
+    "should allow calls on expressions": {
+        input: "<div>{{(content() || bar)(foo)}}</div>",
     },
-    'should allow boolean attribute values': {
-        input: '<tag on=true off=false/>'
+    "should allow boolean attribute values": {
+        input: "<tag on=true off=false/>",
     },
-    '[view] should parse typed views': {
-        input: '{% view Main (Context[String]) %} <p>{{@value}}</p>'
+    "[view] should parse typed views": {
+        input: "{% view Main (Context[String]) %} <p>{{@value}}</p>",
     },
-    '[view] should parse typed views with type parameters': {
-        input: '{% view Main [A,B] (Context[A,B]) %} <p>{{@values}}</p>'
+    "[view] should parse typed views with type parameters": {
+        input: "{% view Main [A,B] (Context[A,B]) %} <p>{{@values}}</p>",
     },
-    '[view] should allow the where syntax': `
+    "[view] should allow the where syntax": `
 
       {% view HeadView where title: String %}
         <title>{{@title}}</title>
     `,
-    'should parse context variables': {
-        input: '<Input name={{@level.name}}/>'
+    "should parse context variables": {
+        input: "<Input name={{@level.name}}/>",
     },
-    '[view] should allow inline context import': {
-        input: '{% view MyView (Context from "./") %} <div>{{@text}}</div>'
+    "[view] should allow inline context import": {
+        input: '{% view MyView (Context from "./") %} <div>{{@text}}</div>',
     },
-    '[view] should allow multiple inline context imports': {
+    "[view] should allow multiple inline context imports": {
         input: `
                     {% view MyView (Context from "./") %} <div>{{@text}}</div>
                     {% view YourView (Context from "./") %} <div/>
-                    `
+                    `,
     },
-    'should allow construct expression': {
-        input: '<TextView android:thing={value=1}>{{Person(@value)}}</TextView>'
+    "[view] should allow without context type": {
+        input: `{% view TestView %}<b>Test</b>`,
     },
-    'should allow view construction': {
-        input: '<p>{{ <Panel(@)> }}</p>'
+    "should allow construct expression": {
+        input: "<TextView android:thing={value=1}>{{Person(@value)}}</TextView>",
     },
-    'should allow fun application': {
-        input: '<p>{{ <panel(1, 2, 3)> }}</p>'
+    "should allow view construction": {
+        input: "<p>{{ <Panel(@)> }}</p>",
     },
-    'should allow fun application with context': {
-        input: '<div>{{ <panel(@,12)> }}</div>'
+    "should allow fun application": {
+        input: "<p>{{ <panel(1, 2, 3)> }}</p>",
     },
-    'should parse list types': {
-        input: '{% fun action [A] (s: String[], a:A[]) = {{  \'${s}${a}\' }} %}'
+    "should allow fun application with context": {
+        input: "<div>{{ <panel(@,12)> }}</div>",
     },
-    'should allow context properties as fun application': {
-        input: '<div>{{ <@action()> }}</div>'
+    "should parse list types": {
+        input: "{% fun action [A] (s: String[], a:A[]) = {{  '${s}${a}' }} %}",
     },
-    'should allow view statements after short fun': {
+    "should allow context properties as fun application": {
+        input: "<div>{{ <@action()> }}</div>",
+    },
+    "should allow view statements after short fun": {
         input: `
 
 {% fun template [A] (d: Date[A], o:A, _:String, __:A[]) = {{String(o)}}  %}
@@ -215,9 +217,9 @@ exports.tests = {
 
     {% endfor %}
 
-  </ul>`
+  </ul>`,
     },
-    'should allow actual code': {
+    "should allow actual code": {
         input: `
         {% import (Table) from "@quenk/wml-widgets/lib/data/table" %}
         {% import (TextField) from "@quenk/wml-widgets/lib/control/text-field" %}
@@ -268,23 +270,23 @@ exports.tests = {
 
         {{@children}}
 
-</Panel>`
+</Panel>`,
     },
-    'should recognize type parameters': {
-        input: '{% fun test[A:String] (a:A) %} {{a}} {% endfun %}'
+    "should recognize type parameters": {
+        input: "{% fun test[A:String] (a:A) %} {{a}} {% endfun %}",
     },
-    'should allow ifs without elses': {
-        input: '{% view Test (Object) %}' +
-            '<div> {% if (value == true) %} <span/> {% endif %} </div>'
+    "should allow ifs without elses": {
+        input: "{% view Test (Object) %}" +
+            "<div> {% if (value == true) %} <span/> {% endif %} </div>",
     },
-    'should allow else if as final branch': {
-        input: '{% view Test(Object) %} <div> ' +
+    "should allow else if as final branch": {
+        input: "{% view Test(Object) %} <div> " +
             '{% if ( show == "span" ) %} <span/> {% else if (show == "div" ) %}' +
-            '<div/> {% endif %} </div>'
+            "<div/> {% endif %} </div>",
     },
-    '[context] should parse constructors': '{% context Test where name: String %}',
-    '[context] should parse generic constructors': '{% context Test where table.name: Text[A] %}',
-    '[context] should parse record types': `{% context Test[A] where
+    "[context] should parse constructors": "{% context Test where name: String %}",
+    "[context] should parse generic constructors": "{% context Test where table.name: Text[A] %}",
+    "[context] should parse record types": `{% context Test[A] where
          
         table.data.record: { 
 
@@ -293,35 +295,35 @@ exports.tests = {
           table.data.list: A[] 
           } 
         %}`,
-    '[context] should parse list types': `{% context Test[A] where table.data.list: A[] %}`,
-    '[context] should parse 2d list types': `{% context Test[A,B] where table.data.list2: A[][] %}`,
-    '[context] should parse 3d list types': `{% context Test[A, B, C] where table.data.list3: A[][][] %}`,
-    '[context] should parse func with no args or parens': `{% context Test where value: Test -> Number %}`,
-    '[context] should parse func with no args': `{% context Test where value: () -> Number %}`,
-    '[context] should parse no-parens func with constructor': `{% context Test where value: String -> String %}`,
-    '[context] should parse no-parens func with generic constructor': `{% context Test where value: Text[A] -> Text[A] %}`,
-    '[context] should parse no-parens func with record arg': `{% context Test where value: {} -> { } %}`,
-    '[context] should parse no-parens func with list arg': `{% context Test where value: String[] -> String[] %}`,
-    '[context] should parse func with cons arg': `{% context Test where value: (String) -> String %}`,
-    '[context] should parse func with 2 cons args': `{% context Test where value: (String, String) -> String %}`,
-    '[context] should parse func with 3 cons args': `{% context Test where value: (String, String, String) -> String %}`,
-    '[context] should parse func with generic cons arg': `{% context Test[A] where value: (Text[A]) -> Text[A] %}`,
-    '[context] should parse func with 2 generic cons args': `{% context Test[A] where value: (Text[A], Text[A]) -> Text[A] %}`,
-    '[context] should parse func with 3 generic cons args': `{% context Test[A] where value: (Text[A], Text[A], Text[A]) -> Text[A] %}`,
-    '[context] should parse func with record arg': `{% context Test where value: ({ }) -> { } %}`,
-    '[context] should parse func with 2 record args': `{% context Test where value: ({ }, { name: String }) -> { } %}`,
-    '[context] should parse func with 3 record args': `{% context Test where value: ({ }, { name: String }, { value: A[]}) -> { } %}`,
-    '[context] should parse func with list arg': `{% context Test where value: (String[]) -> String[] %}`,
-    '[context] should parse func with 2 list args': `{% context Test where value: (String[], String[]) -> String[] %}`,
-    '[context] should parse func with 3 list args': `{% context Test where value: (String[], String[], String[]) -> String[] %}`,
-    '[context] should parse func with func arg': `{% context Test where value: (String -> String) -> String %}`,
-    '[context] should parse func with 2 func args': `{% context Test where value: ((String -> String), (String -> String)) -> String %}`,
-    '[context] should parse func with 3 func args': `{% context Test where
+    "[context] should parse list types": `{% context Test[A] where table.data.list: A[] %}`,
+    "[context] should parse 2d list types": `{% context Test[A,B] where table.data.list2: A[][] %}`,
+    "[context] should parse 3d list types": `{% context Test[A, B, C] where table.data.list3: A[][][] %}`,
+    "[context] should parse func with no args or parens": `{% context Test where value: Test -> Number %}`,
+    "[context] should parse func with no args": `{% context Test where value: () -> Number %}`,
+    "[context] should parse no-parens func with constructor": `{% context Test where value: String -> String %}`,
+    "[context] should parse no-parens func with generic constructor": `{% context Test where value: Text[A] -> Text[A] %}`,
+    "[context] should parse no-parens func with record arg": `{% context Test where value: {} -> { } %}`,
+    "[context] should parse no-parens func with list arg": `{% context Test where value: String[] -> String[] %}`,
+    "[context] should parse func with cons arg": `{% context Test where value: (String) -> String %}`,
+    "[context] should parse func with 2 cons args": `{% context Test where value: (String, String) -> String %}`,
+    "[context] should parse func with 3 cons args": `{% context Test where value: (String, String, String) -> String %}`,
+    "[context] should parse func with generic cons arg": `{% context Test[A] where value: (Text[A]) -> Text[A] %}`,
+    "[context] should parse func with 2 generic cons args": `{% context Test[A] where value: (Text[A], Text[A]) -> Text[A] %}`,
+    "[context] should parse func with 3 generic cons args": `{% context Test[A] where value: (Text[A], Text[A], Text[A]) -> Text[A] %}`,
+    "[context] should parse func with record arg": `{% context Test where value: ({ }) -> { } %}`,
+    "[context] should parse func with 2 record args": `{% context Test where value: ({ }, { name: String }) -> { } %}`,
+    "[context] should parse func with 3 record args": `{% context Test where value: ({ }, { name: String }, { value: A[]}) -> { } %}`,
+    "[context] should parse func with list arg": `{% context Test where value: (String[]) -> String[] %}`,
+    "[context] should parse func with 2 list args": `{% context Test where value: (String[], String[]) -> String[] %}`,
+    "[context] should parse func with 3 list args": `{% context Test where value: (String[], String[], String[]) -> String[] %}`,
+    "[context] should parse func with func arg": `{% context Test where value: (String -> String) -> String %}`,
+    "[context] should parse func with 2 func args": `{% context Test where value: ((String -> String), (String -> String)) -> String %}`,
+    "[context] should parse func with 3 func args": `{% context Test where
           value: ((String -> String), (String -> String), (String -> String)) -> String 
          %}`,
-    '[context] should parse func that return array of generic type': `{% context Test[A] where value: Number -> Text[A][] %}`,
-    '[context] should parse funct that return array of array': `{% context Test where value: String -> Number[][] %}`,
-    '[context] should parse context definitions': {
+    "[context] should parse func that return array of generic type": `{% context Test[A] where value: Number -> Text[A][] %}`,
+    "[context] should parse funct that return array of array": `{% context Test where value: String -> Number[][] %}`,
+    "[context] should parse context definitions": {
         input: `{% context Manager[A] where
 
     name: String,
@@ -385,9 +387,9 @@ exports.tests = {
     funcRetMultiArray: String -> Number[][]
 
 
-        %} `
+        %} `,
     },
-    '[context] should allow optional properties': {
+    "[context] should allow optional properties": {
         input: `{% context AContract where 
           
                   id?: Number,
@@ -398,9 +400,9 @@ exports.tests = {
 
                   name.last?: String
 
-        %}`
+        %}`,
     },
-    '[context] should allow extending': {
+    "[context] should allow extending": {
         input: `{% context AContract where :BContract %}
               {% context CContract where :AContract, :BContract %}
               {% context DContract[Type] where :CContract, member: Type %}
@@ -412,14 +414,14 @@ exports.tests = {
                  member1: B,
                  member2: C
              %}
-             {% context DContract where :AContract, member: DType %}`
-    },
-    '[context] should mark nested properties as optional if all are': `{% context Paper where object."type"?: String %}`,
-    'should parse type statements': `{% type Type = String | Number | Boolean | Type[] | Type -> Type %}`,
-    'should parse tupe types': `{% type Tuple = [Number, String, Number] %}`,
-    'should parse type assertion': '<Panel onClick={{ \e -> foo(e) as User }} />',
-    'should parse partial application in expression': '<Link ww:text={{truncate(50)(@text)}} />',
-    'should transform special primitives': `<div>
+             {% context DContract where :AContract, member: DType %}`,
+    },
+    "[context] should mark nested properties as optional if all are": `{% context Paper where object."type"?: String %}`,
+    "should parse type statements": `{% type Type = String | Number | Boolean | Type[] | Type -> Type %}`,
+    "should parse tupe types": `{% type Tuple = [Number, String, Number] %}`,
+    "should parse type assertion": "<Panel onClick={{ \e -> foo(e) as User }} />",
+    "should parse partial application in expression": "<Link ww:text={{truncate(50)(@text)}} />",
+    "should transform special primitives": `<div>
             {% for kind in [
                             String,
                             Boolean,
@@ -433,51 +435,51 @@ exports.tests = {
               {{ kind | text }}
             {% endfor %}
         </div>`,
-    'should allow casting': `
+    "should allow casting": `
         {% view Test (Object) %}
           <Widget
             val1={{String(@value)}}
             val2={{Number(@value)}}
             val3={{Boolean(@value)}} />
       `,
-    'should parse nullish operator': `<div>{% if value ?? true %}<b>True</b>{% else %}<b>False</b>{% endif %}</div>`,
-    'should parse optional chain operator': `<div>{% if (value?.val) ?? 1 %}<b>True</b>{% else %}<b>False</b>{% endif %}</div>`,
-    '[let] should parse let statements': `{% let head:HeadCtx = {title = "Foo"} %}
+    "should parse nullish operator": `<div>{% if value ?? true %}<b>True</b>{% else %}<b>False</b>{% endif %}</div>`,
+    "should parse optional chain operator": `<div>{% if (value?.val) ?? 1 %}<b>True</b>{% else %}<b>False</b>{% endif %}</div>`,
+    "[let] should parse let statements": `{% let head:HeadCtx = {title = "Foo"} %}
      {% let head2:HeadCtx = {title = "My Title"} %}
     `,
-    '[let] should be usable in a view': `
+    "[let] should be usable in a view": `
         {% view MyView(Object) %}
       {% let head:HeadViewContext = {title = "My Title"} %}
       <h1>{{<HeadView(head)>}}</h1>
     `,
-    '[comment] should parse html comments': `<!-- This is an html comment. -->`,
-    '[comment] should parse wml comments': `{# This is a wml comment #}`,
-    '[comment] should parse wml comments in statements': `{% view Name {# This is a comment! #} (Object) %} <div/> %}`,
-    '[fun] should parse multi dimensional array parameters': `
+    "[comment] should parse html comments": `<!-- This is an html comment. -->`,
+    "[comment] should parse wml comments": `{# This is a wml comment #}`,
+    "[comment] should parse wml comments in statements": `{% view Name {# This is a comment! #} (Object) %} <div/> %}`,
+    "[fun] should parse multi dimensional array parameters": `
     {% fun test (value:List[][]) %}<p/>{% endfun %}`,
-    'should allow index access on context properties': `{% view Test (Object) %}
+    "should allow index access on context properties": `{% view Test (Object) %}
        <div>
         {% if @["type"] == 1 %}
             <div/>
         {% endif %}
       </div>`,
-    'should allow paths to use brackets': `
+    "should allow paths to use brackets": `
    {% view Test (Object) %} 
     <div>
      {% if @values.controls["@type"] %} value {% endif %}
      {% if @values.controls["@type"].value %} value {% endif %}
     </div>`,
-    'should allow 2nd level bracket access': `<div>{% for item in our."items" %} <div/>{% endfor %}</div> `,
-    'should allow type to be used in if statement expression': `<div>{% if item."type" == 1 %}<p/>{% endif %}</div>`,
-    'should support the special wml:attrs attribute': `<Panel wml:attrs={{@panelAttrs}}><div wml:attrs={{divAttrs}}/></Panel>`,
-    'should parse widgets with type arguments': `<div>
+    "should allow 2nd level bracket access": `<div>{% for item in our."items" %} <div/>{% endfor %}</div> `,
+    "should allow type to be used in if statement expression": `<div>{% if item."type" == 1 %}<p/>{% endif %}</div>`,
+    "should support the special wml:attrs attribute": `<Panel wml:attrs={{@panelAttrs}}><div wml:attrs={{divAttrs}}/></Panel>`,
+    "should parse widgets with type arguments": `<div>
       <Panel[Text]>
         <PanelHeader[Text] wml:id="header"/>
         <PanelBody/>
       </Panel>
     </div>`,
-    'should parse view construction with type arguments': `<div>{{<Panel[Text](@)>}}</div>`,
-    'should use createElementNS() recursively for xmlns attribute': `{% view TestView (Object) %}
+    "should parse view construction with type arguments": `<div>{{<Panel[Text](@)>}}</div>`,
+    "should use createElementNS() recursively for xmlns attribute": `{% view TestView (Object) %}
      <svg viewBox="0 0 100 100" xmlns="http://www.w3.org/2000/svg">
       <path
        fill="none"
@@ -493,6 +495,6 @@ exports.tests = {
        m-20,10 h 10
        m-20,10 h 10
        m-20,10 h 10" />
-    </svg>`
+    </svg>`,
 };
 //# sourceMappingURL=test.js.map