marko 4.25.0 → 4.26.0

package/dist/runtime/vdom/morphdom/index.js

@@ -2,30 +2,30 @@
 
 var specialElHandlers = require("./specialElHandlers");
 var KeySequence = require("../../components/KeySequence");
-var componentsUtil = require("../../components/util");
-var existingComponentLookup = componentsUtil.I_;
-var destroyNodeRecursive = componentsUtil.J_;
-var addComponentRootToKeyedElements = componentsUtil.av_;
-var normalizeComponentKey = componentsUtil.aX_;
-var VElement = require("../vdom").bp_;
-var virtualizeElement = VElement.cd_;
-var morphAttrs = VElement.ce_;
+var componentsUtil = require("@internal/components-util");
+var existingComponentLookup = componentsUtil._n_;
+var destroyNodeRecursive = componentsUtil._S_;
+var addComponentRootToKeyedElements = componentsUtil._o_;
+var normalizeComponentKey = componentsUtil._V_;
+var VElement = require("../vdom").bw_;
+var virtualizeElement = VElement.cj_;
+var morphAttrs = VElement.ck_;
 var eventDelegation = require("../../components/event-delegation");
 var fragment = require("./fragment");
 var helpers = require("./helpers");
 var domData = require("../../components/dom-data");
-var keysByDOMNode = domData.al_;
-var componentByDOMNode = domData.K_;
-var vElementByDOMNode = domData.aj_;
-var detachedByDOMNode = domData.ak_;
+var keysByDOMNode = domData._K_;
+var componentByDOMNode = domData._q_;
+var vElementByDOMNode = domData._L_;
+var detachedByDOMNode = domData.aW_;
 
-var insertBefore = helpers.aZ_;
-var insertAfter = helpers.b__;
+var insertBefore = helpers.bg_;
+var insertAfter = helpers.bh_;
 var nextSibling = helpers.b_;
 var firstChild = helpers.a_;
-var removeChild = helpers.ba_;
-var createFragmentNode = fragment.au_;
-var beginFragmentNode = fragment.cl_;
+var removeChild = helpers.bi_;
+var createFragmentNode = fragment._m_;
+var beginFragmentNode = fragment.cr_;
 
 var ELEMENT_NODE = 1;
 var TEXT_NODE = 3;
@@ -43,7 +43,7 @@ function isAutoKey(key) {
 }
 
 function compareNodeNames(fromEl, toEl) {
-  return fromEl.bY_ === toEl.bY_;
+  return fromEl.cd_ === toEl.cd_;
 }
 
 function caseInsensitiveCompare(a, b) {
@@ -52,31 +52,31 @@ function caseInsensitiveCompare(a, b) {
 
 function onNodeAdded(node, componentsContext) {
   if (node.nodeType === ELEMENT_NODE) {
-    eventDelegation.ag_(node, componentsContext);
+    eventDelegation.aV_(node, componentsContext);
   }
 }
 
-function morphdom(fromNode, toNode, doc, componentsContext) {
+function morphdom(fromNode, toNode, host, componentsContext) {
   var globalComponentsContext;
   var isHydrate = false;
   var keySequences = Object.create(null);
 
   if (componentsContext) {
-    globalComponentsContext = componentsContext.k_;
-    isHydrate = globalComponentsContext.l_;
+    globalComponentsContext = componentsContext.r_;
+    isHydrate = globalComponentsContext.a__;
   }
 
   function insertVirtualNodeBefore(vNode, key, referenceEl, parentEl, ownerComponent, parentComponent) {
-    var realNode = vNode.bO_(doc, parentEl.namespaceURI);
+    var realNode = vNode.bU_(host, parentEl.namespaceURI);
     insertBefore(realNode, referenceEl, parentEl);
 
-    if (vNode.bR_ === ELEMENT_NODE || vNode.bR_ === FRAGMENT_NODE) {
+    if (vNode.bX_ === ELEMENT_NODE || vNode.bX_ === FRAGMENT_NODE) {
       if (key) {
         keysByDOMNode.set(realNode, key);
-        (isAutoKey(key) ? parentComponent : ownerComponent).q_[key] = realNode;
+        (isAutoKey(key) ? parentComponent : ownerComponent).N_[key] = realNode;
       }
 
-      if (vNode.bY_ !== "textarea") {
+      if (vNode.cd_ !== "textarea") {
         morphChildren(realNode, vNode, parentComponent);
       }
 
@@ -85,12 +85,12 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
   }
 
   function insertVirtualComponentBefore(vComponent, referenceNode, referenceNodeParentEl, component, key, ownerComponent, parentComponent) {
-    var rootNode = component.Q_ = insertBefore(createFragmentNode(), referenceNode, referenceNodeParentEl);
+    var rootNode = component._E_ = insertBefore(createFragmentNode(), referenceNode, referenceNodeParentEl);
     componentByDOMNode.set(rootNode, component);
 
     if (key && ownerComponent) {
       key = normalizeComponentKey(key, parentComponent.id);
-      addComponentRootToKeyedElements(ownerComponent.q_, key, rootNode, component.id);
+      addComponentRootToKeyedElements(ownerComponent.N_, key, rootNode, component.id);
       keysByDOMNode.set(rootNode, key);
     }
 
@@ -98,7 +98,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
   }
 
   function morphComponent(component, vComponent) {
-    morphChildren(component.Q_, vComponent, component);
+    morphChildren(component._E_, vComponent, component);
   }
 
   var detachedNodes = [];
@@ -134,28 +134,28 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
 
     outer: while (curToNodeChild) {
       toNextSibling = curToNodeChild.b_;
-      curToNodeType = curToNodeChild.bR_;
-      curToNodeKey = curToNodeChild.bS_;
+      curToNodeType = curToNodeChild.bX_;
+      curToNodeKey = curToNodeChild.bY_;
 
       // Skip <!doctype>
       if (curFromNodeChild && curFromNodeChild.nodeType === DOCTYPE_NODE) {
         curFromNodeChild = nextSibling(curFromNodeChild);
       }
 
-      var ownerComponent = curToNodeChild.aU_ || parentComponent;
+      var ownerComponent = curToNodeChild._N_ || parentComponent;
       var referenceComponent;
 
       if (curToNodeType === COMPONENT_NODE) {
-        var component = curToNodeChild.n_;
+        var component = curToNodeChild.v_;
         if ((matchingFromComponent = existingComponentLookup[component.id]) === undefined) {
           if (isHydrate === true) {
             var rootNode = beginFragmentNode(curFromNodeChild, fromNode);
-            component.Q_ = rootNode;
+            component._E_ = rootNode;
             componentByDOMNode.set(rootNode, component);
 
             if (ownerComponent && curToNodeKey) {
               curToNodeKey = normalizeComponentKey(curToNodeKey, parentComponent.id);
-              addComponentRootToKeyedElements(ownerComponent.q_, curToNodeKey, rootNode, component.id);
+              addComponentRootToKeyedElements(ownerComponent.N_, curToNodeKey, rootNode, component.id);
 
               keysByDOMNode.set(rootNode, curToNodeKey);
             }
@@ -167,23 +167,23 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
             insertVirtualComponentBefore(curToNodeChild, curFromNodeChild, fromNode, component, curToNodeKey, ownerComponent, parentComponent);
           }
         } else {
-          if (matchingFromComponent.Q_ !== curFromNodeChild) {
-            if (curFromNodeChild && (fromComponent = componentByDOMNode.get(curFromNodeChild)) && globalComponentsContext._Z_[fromComponent.id] === undefined) {
+          if (matchingFromComponent._E_ !== curFromNodeChild) {
+            if (curFromNodeChild && (fromComponent = componentByDOMNode.get(curFromNodeChild)) && globalComponentsContext.s_[fromComponent.id] === undefined) {
               // The component associated with the current real DOM node was not rendered
               // so we should just remove it out of the real DOM by destroying it
-              curFromNodeChild = nextSibling(fromComponent.Q_);
+              curFromNodeChild = nextSibling(fromComponent._E_);
               destroyComponent(fromComponent);
               continue;
             }
 
             // We need to move the existing component into
             // the correct location
-            insertBefore(matchingFromComponent.Q_, curFromNodeChild, fromNode);
+            insertBefore(matchingFromComponent._E_, curFromNodeChild, fromNode);
           } else {
             curFromNodeChild = curFromNodeChild && nextSibling(curFromNodeChild);
           }
 
-          if (!curToNodeChild.t_) {
+          if (!curToNodeChild.ae_) {
             morphComponent(component, curToNodeChild);
           }
         }
@@ -206,7 +206,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
 
         // We have a keyed element. This is the fast path for matching
         // up elements
-        curToNodeKey = (keySequences[referenceComponent.id] || (keySequences[referenceComponent.id] = new KeySequence()))._Q_(curToNodeKey);
+        curToNodeKey = (keySequences[referenceComponent.id] || (keySequences[referenceComponent.id] = new KeySequence())).aN_(curToNodeKey);
 
         if (curFromNodeChild) {
           curFromNodeKey = keysByDOMNode.get(curFromNodeChild);
@@ -216,7 +216,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
 
         if (curFromNodeKey === curToNodeKey) {
           // Elements line up. Now we just have to make sure they are compatible
-          if (!curToNodeChild.t_) {
+          if (!curToNodeChild.ae_) {
             // We just skip over the fromNode if it is preserved
 
             if (compareNodeNames(curToNodeChild, curVFromNodeChild)) {
@@ -230,16 +230,16 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
             }
           }
         } else {
-          matchingFromEl = referenceComponent.q_[curToNodeKey];
+          matchingFromEl = referenceComponent.N_[curToNodeKey];
           if (matchingFromEl === undefined || matchingFromEl === curFromNodeChild) {
             if (isHydrate === true && curFromNodeChild) {
-              if (curFromNodeChild.nodeType === ELEMENT_NODE && (curToNodeChild.t_ || caseInsensitiveCompare(curFromNodeChild.nodeName, curToNodeChild.bY_ || ""))) {
+              if (curFromNodeChild.nodeType === ELEMENT_NODE && (curToNodeChild.ae_ || caseInsensitiveCompare(curFromNodeChild.nodeName, curToNodeChild.cd_ || ""))) {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
-                curVFromNodeChild.bY_ = curToNodeChild.bY_;
+                curVFromNodeChild.cd_ = curToNodeChild.cd_;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
-                referenceComponent.q_[curToNodeKey] = curFromNodeChild;
+                referenceComponent.N_[curToNodeKey] = curFromNodeChild;
 
-                if (curToNodeChild.t_) {
+                if (curToNodeChild.ae_) {
                   vElementByDOMNode.set(curFromNodeChild, curVFromNodeChild);
                 } else {
                   morphEl(curFromNodeChild, curVFromNodeChild, curToNodeChild, parentComponent);
@@ -248,7 +248,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
                 curToNodeChild = toNextSibling;
                 curFromNodeChild = fromNextSibling;
                 continue;
-              } else if (curToNodeChild.bR_ === FRAGMENT_NODE && curFromNodeChild.nodeType === COMMENT_NODE) {
+              } else if (curToNodeChild.bX_ === FRAGMENT_NODE && curFromNodeChild.nodeType === COMMENT_NODE) {
                 var content = curFromNodeChild.nodeValue;
                 if (content == "F#" + curToNodeKeyOriginal) {
                   var endNode = curFromNodeChild.nextSibling;
@@ -275,11 +275,11 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
                   var fragment = createFragmentNode(curFromNodeChild, endNode.nextSibling, fromNode);
                   keysByDOMNode.set(fragment, curToNodeKey);
                   vElementByDOMNode.set(fragment, curToNodeChild);
-                  referenceComponent.q_[curToNodeKey] = fragment;
+                  referenceComponent.N_[curToNodeKey] = fragment;
                   removeChild(curFromNodeChild);
                   removeChild(endNode);
 
-                  if (!curToNodeChild.t_) {
+                  if (!curToNodeChild.ae_) {
                     morphChildren(fragment, curToNodeChild, parentComponent);
                   }
 
@@ -297,7 +297,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
               detachedByDOMNode.set(matchingFromEl, undefined);
             }
 
-            if (!curToNodeChild.t_) {
+            if (!curToNodeChild.ae_) {
               curVFromNodeChild = vElementByDOMNode.get(matchingFromEl);
 
               if (compareNodeNames(curVFromNodeChild, curToNodeChild)) {
@@ -313,7 +313,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
                   // B <-> C <-- We are here
                   // C     B
 
-                  if (toNextSibling && toNextSibling.bS_ === curFromNodeKey) {
+                  if (toNextSibling && toNextSibling.bY_ === curFromNodeKey) {
                     // Single element swap
 
                     // We want to stay on the current real DOM node
@@ -382,7 +382,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
           // not compatible with the current "to" node
           curFromNodeChild = fromNextSibling;
 
-          if (!globalComponentsContext._Z_[fromComponent.id]) {
+          if (!globalComponentsContext.s_[fromComponent.id]) {
             destroyComponent(fromComponent);
           }
 
@@ -401,15 +401,15 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
               if (isHydrate === true) {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
 
-                if (caseInsensitiveCompare(curVFromNodeChild.bY_, curToNodeChild.bY_)) {
-                  curVFromNodeChild.bY_ = curToNodeChild.bY_;
+                if (caseInsensitiveCompare(curVFromNodeChild.cd_, curToNodeChild.cd_)) {
+                  curVFromNodeChild.cd_ = curToNodeChild.cd_;
                 }
               } else {
                 // Skip over nodes that don't look like ours...
                 curFromNodeChild = fromNextSibling;
                 continue;
               }
-            } else if (curFromNodeKey = curVFromNodeChild.bS_) {
+            } else if (curFromNodeKey = curVFromNodeChild.bY_) {
               // We have a keyed element here but our target VDOM node
               // is not keyed so this not doesn't belong
               isCompatible = false;
@@ -428,8 +428,12 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
             isCompatible = true;
             // Simply update nodeValue on the original node to
             // change the text value
-            if (curFromNodeChild.nodeValue !== curToNodeChild.bQ_) {
-              curFromNodeChild.nodeValue = curToNodeChild.bQ_;
+
+            if (isHydrate === true && toNextSibling && curFromNodeType === TEXT_NODE && toNextSibling.bX_ === TEXT_NODE) {
+              fromNextSibling = curFromNodeChild.splitText(curToNodeChild.bW_.length);
+            }
+            if (curFromNodeChild.nodeValue !== curToNodeChild.bW_) {
+              curFromNodeChild.nodeValue = curToNodeChild.bW_;
             }
           }
         }
@@ -456,10 +460,10 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
     }
 
     // We have processed all of the "to nodes".
-    if (fromNode.ck_) {
+    if (fromNode.cq_) {
       // If we are in an unfinished fragment, we have reached the end of the nodes
       // we were matching up and need to end the fragment
-      fromNode.ck_(curFromNodeChild);
+      fromNode.cq_(curFromNodeChild);
     } else {
       // If curFromNodeChild is non-null then we still have some from nodes
       // left over that need to be removed
@@ -470,7 +474,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
 
         if (fromComponent = componentByDOMNode.get(curFromNodeChild)) {
           curFromNodeChild = fromNextSibling;
-          if (!globalComponentsContext._Z_[fromComponent.id]) {
+          if (!globalComponentsContext.s_[fromComponent.id]) {
             destroyComponent(fromComponent);
           }
           continue;
@@ -484,7 +488,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
         if (!curFromNodeKey || isAutoKey(curFromNodeKey)) {
           referenceComponent = parentComponent;
         } else {
-          referenceComponent = curVFromNodeChild && curVFromNodeChild.aU_;
+          referenceComponent = curVFromNodeChild && curVFromNodeChild._N_;
         }
 
         detachNode(curFromNodeChild, fromNode, referenceComponent);
@@ -495,16 +499,16 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
   }
 
   function morphEl(fromEl, vFromEl, toEl, parentComponent) {
-    var nodeName = toEl.bY_;
+    var nodeName = toEl.cd_;
 
-    var constId = toEl.c__;
-    if (constId !== undefined && vFromEl.c__ === constId) {
+    var constId = toEl.cf_;
+    if (constId !== undefined && vFromEl.cf_ === constId) {
       return;
     }
 
     morphAttrs(fromEl, vFromEl, toEl);
 
-    if (toEl.s_) {
+    if (toEl.ad_) {
       return;
     }
 
@@ -521,7 +525,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
   // eslint-disable-next-line no-constant-condition
 
 
-  morphChildren(fromNode, toNode, toNode.n_);
+  morphChildren(fromNode, toNode, toNode.v_);
 
   detachedNodes.forEach(function (node) {
     var detachedFromComponent = detachedByDOMNode.get(node);
@@ -535,7 +539,7 @@ function morphdom(fromNode, toNode, doc, componentsContext) {
       } else if (node.parentNode) {
         destroyNodeRecursive(node, detachedFromComponent !== true && detachedFromComponent);
 
-        if (eventDelegation._f_(node) != false) {
+        if (eventDelegation.ap_(node) != false) {
           removeChild(node);
         }
       }

package/dist/runtime/vdom/morphdom/specialElHandlers.js

@@ -13,7 +13,7 @@ function forEachOption(el, fn, i) {
   var curChild = el.a_;
 
   while (curChild) {
-    if (curChild.bY_ === "option") {
+    if (curChild.cd_ === "option") {
       fn(curChild, ++i);
     } else {
       i = forEachOption(curChild, fn, i);
@@ -48,21 +48,21 @@ SpecialElHandlers.prototype = {
     syncBooleanAttrProp(fromEl, toEl, "checked");
     syncBooleanAttrProp(fromEl, toEl, "disabled");
 
-    if (fromEl.value != toEl.w_) {
-      fromEl.value = toEl.w_;
+    if (fromEl.value != toEl.g_) {
+      fromEl.value = toEl.g_;
     }
 
-    if (fromEl.hasAttribute("value") && !toEl.cb_("value")) {
+    if (fromEl.hasAttribute("value") && !toEl.ch_("value")) {
       fromEl.removeAttribute("value");
     }
   },
 
   textarea: function (fromEl, toEl) {
-    if (toEl.cj_) {
+    if (toEl.cp_) {
       return;
     }
 
-    var newValue = toEl.w_;
+    var newValue = toEl.g_;
     if (fromEl.value != newValue) {
       fromEl.value = newValue;
     }
@@ -81,10 +81,10 @@ SpecialElHandlers.prototype = {
     }
   },
   select: function (fromEl, toEl) {
-    if (!toEl.cb_("multiple")) {
+    if (!toEl.ch_("multiple")) {
       var selected = 0;
       forEachOption(toEl, function (option, i) {
-        if (option.cb_("selected")) {
+        if (option.ch_("selected")) {
           selected = i;
         }
       }, -1);

package/dist/runtime/vdom/preserve-attrs.js

@@ -12,4 +12,4 @@ function removePreservedAttributes(attrs, props) {
   return attrs;
 }
 
-require("./VElement").cc_ = removePreservedAttributes;
+require("./VElement").ci_ = removePreservedAttributes;

package/dist/runtime/vdom/vdom.js

@@ -7,13 +7,12 @@ var VComponent = require("./VComponent");
 var VFragment = require("./VFragment");
 var parseHTML = require("./parse-html");
 
-var defaultDocument = typeof document != "undefined" && document;
 var specialHtmlRegexp = /[&<]/;
 
 function virtualizeChildNodes(node, vdomParent, ownerComponent) {
   var curChild = node.firstChild;
   while (curChild) {
-    vdomParent.bI_(virtualize(curChild, ownerComponent));
+    vdomParent.bO_(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 }
@@ -21,7 +20,7 @@ function virtualizeChildNodes(node, vdomParent, ownerComponent) {
 function virtualize(node, ownerComponent) {
   switch (node.nodeType) {
     case 1:
-      return VElement.cd_(node, virtualizeChildNodes, ownerComponent);
+      return VElement.cj_(node, virtualizeChildNodes, ownerComponent);
     case 3:
       return new VText(node.nodeValue, ownerComponent);
     case 8:
@@ -33,7 +32,7 @@ function virtualize(node, ownerComponent) {
   }
 }
 
-function virtualizeHTML(html, doc, ownerComponent) {
+function virtualizeHTML(html, ownerComponent) {
   if (!specialHtmlRegexp.test(html)) {
     return new VText(html, ownerComponent);
   }
@@ -42,7 +41,7 @@ function virtualizeHTML(html, doc, ownerComponent) {
   var curChild = parseHTML(html);
 
   while (curChild) {
-    vdomFragment.bI_(virtualize(curChild, ownerComponent));
+    vdomFragment.bO_(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 
@@ -64,13 +63,13 @@ Node_prototype.t = function (value) {
       value = "";
     } else if (type === "object") {
       if (value.toHTML) {
-        vdomNode = virtualizeHTML(value.toHTML(), document);
+        vdomNode = virtualizeHTML(value.toHTML());
       }
     }
   }
 
-  this.bI_(vdomNode || new VText(value.toString()));
-  return this.ca_();
+  this.bO_(vdomNode || new VText(value.toString()));
+  return this.cg_();
 };
 
 /**
@@ -78,20 +77,19 @@ Node_prototype.t = function (value) {
  * @param  {String} value The value for the new Comment node
  */
 Node_prototype.c = function (value) {
-  this.bI_(new VComment(value));
-  return this.ca_();
+  this.bO_(new VComment(value));
+  return this.cg_();
 };
 
-Node_prototype.bM_ = function () {
-  return this.bI_(new VDocumentFragment());
+Node_prototype.bS_ = function () {
+  return this.bO_(new VDocumentFragment());
 };
 
-exports.br_ = VComment;
-exports.bq_ = VDocumentFragment;
-exports.bp_ = VElement;
-exports.bs_ = VText;
-exports.bt_ = VComponent;
-exports.bu_ = VFragment;
-exports.cd_ = virtualize;
-exports.bv_ = virtualizeHTML;
-exports.bw_ = defaultDocument;
+exports.by_ = VComment;
+exports.bx_ = VDocumentFragment;
+exports.bw_ = VElement;
+exports.bz_ = VText;
+exports.bA_ = VComponent;
+exports.bB_ = VFragment;
+exports.cj_ = virtualize;
+exports.bC_ = virtualizeHTML;

package/docs/body-content.md

@@ -4,8 +4,8 @@ We're used to passing body content to HTML tags. When you do this, the tag has c
 
 ```html
 <details>
-  <summary>Hello <strong>World</strong></summary> This is some
-  <em>content</em> that can be toggled.
+  <summary>Hello <strong>World</strong></summary>
+  This is some <em>content</em> that can be toggled.
 </details>
 ```
 

package/docs/class-components.md

@@ -142,12 +142,12 @@ If you target browsers that does not support classes, a plain object of methods
 
 ```js
 module.exports = {
-  onCreate: function() {
+  onCreate: function () {
     this.state = {
       count: 0
     };
   },
-  increment: function() {
+  increment: function () {
     this.state.count++;
   }
 };
@@ -893,7 +893,7 @@ class {
 > **ProTip:** When a lifecycle event occurs in the browser, the corresponding event is emitted on the component instance. A parent component, or other code that has access to the component instance, can listen for these events. For example:
 >
 > ```js
-> component.on("input", function(input, out) {
+> component.on("input", function (input, out) {
 >   // The component received an input
 > });
 > ```

package/docs/express.md

@@ -28,7 +28,7 @@ var app = express();
 
 app.use(markoExpress()); //enable res.marko(template, data)
 
-app.get("/", function(req, res) {
+app.get("/", function (req, res) {
   res.marko(template, {
     name: "Frank",
     count: 30,

package/docs/lasso.md

@@ -60,9 +60,7 @@ Marko templates can be imported and rendered by any JavaScript module. The code
 _client.js_
 
 ```js
-require("./components/app/index.marko")
-  .renderSync({})
-  .appendTo(document.body);
+require("./components/app/index.marko").renderSync({}).appendTo(document.body);
 ```
 
 When Lasso.js bundles up the code above it will automatically bundle up the required `./components/app/index.marko` file.
@@ -124,9 +122,8 @@ To retrieve the list of server rendered components, do:
 
 ```javascript
 template.render(data, (err, output) => {
-  const renderedComponentsList = require("marko/components").getRenderedComponents(
-    output.out
-  );
+  const renderedComponentsList =
+    require("marko/components").getRenderedComponents(output.out);
   const html = output.getOutput();
 });
 res.json({

package/docs/marko-v4.md

@@ -82,7 +82,7 @@ function render(data, out) {
   if (colors && colors.length) {
     out.w("<ul>");
 
-    marko_forEach(colors, function(color) {
+    marko_forEach(colors, function (color) {
       out.w('<li class="color">' + marko_escapeXml(color) + "</li>");
     });
 
@@ -109,7 +109,7 @@ function render(data, out) {
   if (colors && colors.length) {
     out.be("UL");
 
-    marko_forEach(colors, function(color) {
+    marko_forEach(colors, function (color) {
       out.e("LI", marko_attrs0, 1).t(marko_str(color));
     });
 
@@ -643,7 +643,7 @@ $ var age = calculateAge(state.birthday);
 **Old:**
 
 ```js
-template.render({}, function(err, html, out) {});
+template.render({}, function (err, html, out) {});
 ```
 
 **New:**
@@ -651,8 +651,8 @@ template.render({}, function(err, html, out) {});
 ```js
 template
   .render({})
-  .then(function(result) {})
-  .catch(function(err) {});
+  .then(function (result) {})
+  .catch(function (err) {});
 
 // render() can now be used with async/await
 var out = await template.render({});

package/docs/redux.md

@@ -40,7 +40,7 @@ class {
 ### `reducer.js`
 
 ```js
-module.exports = function(state, action) {
+module.exports = function (state, action) {
   state = state || { value: 0 };
 
   // Additional reducer logic here…

package/docs/server-side-rendering.md

@@ -5,7 +5,7 @@ Marko allows any Marko template/UI component to be rendered on the server or in
 ```js
 var template = require("./template"); // Import ./template.marko
 
-module.exports = function(req, res) {
+module.exports = function (req, res) {
   res.setHeader("Content-Type", "text/html; charset=utf-8");
   template.render({ name: "Frank" }, res);
 };
@@ -16,7 +16,7 @@ Marko can also provide you with a `Readable` stream.
 ```js
 var template = require("./template"); // Import ./template.marko
 
-module.exports = function(req) {
+module.exports = function (req) {
   // Return a Readable stream for someone to do something with:
   return template.stream({ name: "Frank" });
 };