marko 5.36.5 → 5.37.0

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

@@ -1,31 +1,31 @@
 "use strict";
 var componentsUtil = require("@internal/components-util");
-var existingComponentLookup = componentsUtil._m_;
-var destroyNodeRecursive = componentsUtil._S_;
+var existingComponentLookup = componentsUtil.___componentLookup;
+var destroyNodeRecursive = componentsUtil.___destroyNodeRecursive;
 var addComponentRootToKeyedElements =
-componentsUtil._n_;
-var normalizeComponentKey = componentsUtil._V_;
+componentsUtil.___addComponentRootToKeyedElements;
+var normalizeComponentKey = componentsUtil.___normalizeComponentKey;
 var domData = require("../../components/dom-data");
 var eventDelegation = require("../../components/event-delegation");
 var KeySequence = require("../../components/KeySequence");
-var VElement = require("../vdom").bz_;
+var VElement = require("../vdom").___VElement;
 var fragment = require("./fragment");
 var helpers = require("./helpers");
 var isTextOnly = require("../is-text-only");
-var virtualizeElement = VElement.ck_;
-var morphAttrs = VElement.cl_;
-var keysByDOMNode = domData._o_;
-var componentByDOMNode = domData._q_;
-var vElementByDOMNode = domData._L_;
-var detachedByDOMNode = domData.aX_;
-
-var insertBefore = helpers.bg_;
-var insertAfter = helpers.bh_;
-var nextSibling = helpers.cp_;
-var firstChild = helpers.aB_;
-var removeChild = helpers.bi_;
-var createFragmentNode = fragment._l_;
-var beginFragmentNode = fragment.ct_;
+var virtualizeElement = VElement.___virtualize;
+var morphAttrs = VElement.___morphAttrs;
+var keysByDOMNode = domData.___keyByDOMNode;
+var componentByDOMNode = domData.___componentByDOMNode;
+var vElementByDOMNode = domData.___vElementByDOMNode;
+var detachedByDOMNode = domData.___detachedByDOMNode;
+
+var insertBefore = helpers.___insertBefore;
+var insertAfter = helpers.___insertAfter;
+var nextSibling = helpers.___nextSibling;
+var firstChild = helpers.___firstChild;
+var removeChild = helpers.___removeChild;
+var createFragmentNode = fragment.___createFragmentNode;
+var beginFragmentNode = fragment.___beginFragmentNode;
 
 var ELEMENT_NODE = 1;
 var TEXT_NODE = 3;
@@ -43,7 +43,7 @@ function isAutoKey(key) {
 }
 
 function compareNodeNames(fromEl, toEl) {
-  return fromEl.cg_ === toEl.cg_;
+  return fromEl.___nodeName === toEl.___nodeName;
 }
 
 function caseInsensitiveCompare(a, b) {
@@ -52,7 +52,7 @@ function caseInsensitiveCompare(a, b) {
 
 function onNodeAdded(node, componentsContext) {
   if (node.nodeType === ELEMENT_NODE) {
-    eventDelegation.aW_(node, componentsContext);
+    eventDelegation.___handleNodeAttach(node, componentsContext);
   }
 }
 
@@ -62,8 +62,8 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   var keySequences = Object.create(null);
 
   if (componentsContext) {
-    globalComponentsContext = componentsContext.q_;
-    isHydrate = globalComponentsContext.a__;
+    globalComponentsContext = componentsContext.___globalContext;
+    isHydrate = globalComponentsContext.___isHydrate;
   }
 
   function insertVirtualNodeBefore(
@@ -74,21 +74,21 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var realNode = vNode.bp_(host, parentEl.namespaceURI);
+    var realNode = vNode.___actualize(host, parentEl.namespaceURI);
     insertBefore(realNode, referenceEl, parentEl);
 
     if (
-    vNode.c__ === ELEMENT_NODE ||
-    vNode.c__ === FRAGMENT_NODE)
+    vNode.___nodeType === ELEMENT_NODE ||
+    vNode.___nodeType === FRAGMENT_NODE)
     {
       if (key) {
         keysByDOMNode.set(realNode, key);
-        (isAutoKey(key) ? parentComponent : ownerComponent).L_[
+        (isAutoKey(key) ? parentComponent : ownerComponent).___keyedElements[
         key] =
         realNode;
       }
 
-      if (!isTextOnly(vNode.cg_)) {
+      if (!isTextOnly(vNode.___nodeName)) {
         morphChildren(realNode, vNode, parentComponent);
       }
 
@@ -105,7 +105,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   ownerComponent,
   parentComponent)
   {
-    var rootNode = component._F_ = insertBefore(
+    var rootNode = component.___rootNode = insertBefore(
       createFragmentNode(),
       referenceNode,
       referenceNodeParentEl
@@ -115,7 +115,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     if (key && ownerComponent) {
       key = normalizeComponentKey(key, parentComponent.id);
       addComponentRootToKeyedElements(
-        ownerComponent.L_,
+        ownerComponent.___keyedElements,
         key,
         rootNode,
         component.id
@@ -127,7 +127,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphComponent(component, vComponent) {
-    morphChildren(component._F_, vComponent, component);
+    morphChildren(component.___rootNode, vComponent, component);
   }
 
   var detachedNodes = [];
@@ -148,7 +148,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
   function morphChildren(fromNode, toNode, parentComponent) {
     var curFromNodeChild = firstChild(fromNode);
-    var curToNodeChild = toNode.aB_;
+    var curToNodeChild = toNode.___firstChild;
 
     var curToNodeKey;
     var curFromNodeKey;
@@ -162,27 +162,27 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     var fromComponent;
 
     outer: while (curToNodeChild) {
-      toNextSibling = curToNodeChild.cp_;
-      curToNodeType = curToNodeChild.c__;
-      curToNodeKey = curToNodeChild.ca_;
+      toNextSibling = curToNodeChild.___nextSibling;
+      curToNodeType = curToNodeChild.___nodeType;
+      curToNodeKey = curToNodeChild.___key;
 
       // Skip <!doctype>
       if (curFromNodeChild && curFromNodeChild.nodeType === DOCTYPE_NODE) {
         curFromNodeChild = nextSibling(curFromNodeChild);
       }
 
-      var ownerComponent = curToNodeChild._N_ || parentComponent;
+      var ownerComponent = curToNodeChild.___ownerComponent || parentComponent;
       var referenceComponent;
 
       if (curToNodeType === COMPONENT_NODE) {
-        var component = curToNodeChild.t_;
+        var component = curToNodeChild.___component;
         if (
         (matchingFromComponent = existingComponentLookup[component.id]) ===
         undefined)
         {
           if (isHydrate) {
             var rootNode = beginFragmentNode(curFromNodeChild, fromNode);
-            component._F_ = rootNode;
+            component.___rootNode = rootNode;
             componentByDOMNode.set(rootNode, component);
 
             if (ownerComponent && curToNodeKey) {
@@ -191,7 +191,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 parentComponent.id
               );
               addComponentRootToKeyedElements(
-                ownerComponent.L_,
+                ownerComponent.___keyedElements,
                 curToNodeKey,
                 rootNode,
                 component.id
@@ -215,17 +215,17 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             );
           }
         } else {
-          if (matchingFromComponent._F_ !== curFromNodeChild) {
+          if (matchingFromComponent.___rootNode !== curFromNodeChild) {
             if (
             curFromNodeChild && (
             fromComponent = componentByDOMNode.get(curFromNodeChild)) &&
-            globalComponentsContext.r_[
+            globalComponentsContext.___renderedComponentsById[
             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._F_);
+              curFromNodeChild = nextSibling(fromComponent.___rootNode);
               destroyComponent(fromComponent);
               continue;
             }
@@ -233,7 +233,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             // We need to move the existing component into
             // the correct location
             insertBefore(
-              matchingFromComponent._F_,
+              matchingFromComponent.___rootNode,
               curFromNodeChild,
               fromNode
             );
@@ -242,7 +242,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             curFromNodeChild && nextSibling(curFromNodeChild);
           }
 
-          if (!curToNodeChild.ae_) {
+          if (!curToNodeChild.___preserve) {
             morphComponent(component, curToNodeChild);
           }
         }
@@ -267,8 +267,8 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         // up elements
         curToNodeKey = (
         keySequences[referenceComponent.id] || (
-        keySequences[referenceComponent.id] = new KeySequence())).aO_(
-          curToNodeKey);
+        keySequences[referenceComponent.id] = new KeySequence())).
+        ___nextKey(curToNodeKey);
 
         if (curFromNodeChild) {
           curFromNodeKey = keysByDOMNode.get(curFromNodeChild);
@@ -278,12 +278,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
         if (curFromNodeKey === curToNodeKey) {
           // Elements line up. Now we just have to make sure they are compatible
-          if (!curToNodeChild.ae_) {
+          if (!curToNodeChild.___preserve) {
             // We just skip over the fromNode if it is preserved
 
             if (
             curVFromNodeChild &&
-            curToNodeType === curVFromNodeChild.c__ && (
+            curToNodeType === curVFromNodeChild.___nodeType && (
             curToNodeType !== ELEMENT_NODE ||
             compareNodeNames(curToNodeChild, curVFromNodeChild)))
             {
@@ -317,7 +317,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             }
           }
         } else {
-          matchingFromEl = referenceComponent.L_[curToNodeKey];
+          matchingFromEl = referenceComponent.___keyedElements[curToNodeKey];
           if (
           matchingFromEl === undefined ||
           matchingFromEl === curFromNodeChild)
@@ -325,19 +325,19 @@ function morphdom(fromNode, toNode, host, componentsContext) {
             if (isHydrate && curFromNodeChild) {
               if (
               curFromNodeChild.nodeType === ELEMENT_NODE && (
-              curToNodeChild.ae_ ||
+              curToNodeChild.___preserve ||
               caseInsensitiveCompare(
                 curFromNodeChild.nodeName,
-                curToNodeChild.cg_ || ""
+                curToNodeChild.___nodeName || ""
               )))
               {
                 curVFromNodeChild = virtualizeElement(curFromNodeChild);
-                curVFromNodeChild.cg_ = curToNodeChild.cg_;
+                curVFromNodeChild.___nodeName = curToNodeChild.___nodeName;
                 keysByDOMNode.set(curFromNodeChild, curToNodeKey);
-                referenceComponent.L_[curToNodeKey] =
+                referenceComponent.___keyedElements[curToNodeKey] =
                 curFromNodeChild;
 
-                if (curToNodeChild.ae_) {
+                if (curToNodeChild.___preserve) {
                   vElementByDOMNode.set(curFromNodeChild, curVFromNodeChild);
                 } else {
                   morphEl(
@@ -352,7 +352,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                 curFromNodeChild = fromNextSibling;
                 continue;
               } else if (
-              curToNodeChild.c__ === FRAGMENT_NODE &&
+              curToNodeChild.___nodeType === FRAGMENT_NODE &&
               curFromNodeChild.nodeType === COMMENT_NODE)
               {
                 var content = curFromNodeChild.nodeValue;
@@ -384,11 +384,11 @@ function morphdom(fromNode, toNode, host, componentsContext) {
                   );
                   keysByDOMNode.set(fragment, curToNodeKey);
                   vElementByDOMNode.set(fragment, curToNodeChild);
-                  referenceComponent.L_[curToNodeKey] = fragment;
+                  referenceComponent.___keyedElements[curToNodeKey] = fragment;
                   removeChild(curFromNodeChild);
                   removeChild(endNode);
 
-                  if (!curToNodeChild.ae_) {
+                  if (!curToNodeChild.___preserve) {
                     morphChildren(fragment, curToNodeChild, parentComponent);
                   }
 
@@ -413,12 +413,12 @@ function morphdom(fromNode, toNode, host, componentsContext) {
               detachedByDOMNode.set(matchingFromEl, undefined);
             }
 
-            if (!curToNodeChild.ae_) {
+            if (!curToNodeChild.___preserve) {
               curVFromNodeChild = vElementByDOMNode.get(matchingFromEl);
 
               if (
               curVFromNodeChild &&
-              curToNodeType === curVFromNodeChild.c__ && (
+              curToNodeType === curVFromNodeChild.___nodeType && (
               curToNodeType !== ELEMENT_NODE ||
               compareNodeNames(curVFromNodeChild, curToNodeChild)))
               {
@@ -436,7 +436,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                   if (
                   toNextSibling &&
-                  toNextSibling.ca_ === curFromNodeKey)
+                  toNextSibling.___key === curFromNodeKey)
                   {
                     // Single element swap
 
@@ -527,7 +527,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           curFromNodeChild = fromNextSibling;
 
           if (
-          !globalComponentsContext.r_[fromComponent.id])
+          !globalComponentsContext.___renderedComponentsById[fromComponent.id])
           {
             destroyComponent(fromComponent);
           }
@@ -549,18 +549,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
 
                 if (
                 caseInsensitiveCompare(
-                  curVFromNodeChild.cg_,
-                  curToNodeChild.cg_
+                  curVFromNodeChild.___nodeName,
+                  curToNodeChild.___nodeName
                 ))
                 {
-                  curVFromNodeChild.cg_ = curToNodeChild.cg_;
+                  curVFromNodeChild.___nodeName = curToNodeChild.___nodeName;
                 }
               } else {
                 // Skip over nodes that don't look like ours...
                 curFromNodeChild = fromNextSibling;
                 continue;
               }
-            } else if (curFromNodeKey = curVFromNodeChild.ca_) {
+            } else if (curFromNodeKey = curVFromNodeChild.___key) {
               // We have a keyed element here but our target VDOM node
               // is not keyed so this not doesn't belong
               isCompatible = false;
@@ -587,18 +587,18 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           {
             // Both nodes being compared are Text or Comment nodes
             isCompatible = true;
-            var curToNodeValue = curToNodeChild.bZ_;
+            var curToNodeValue = curToNodeChild.___nodeValue;
             var curFromNodeValue = curFromNodeChild.nodeValue;
             if (curFromNodeValue !== curToNodeValue) {
               if (
               isHydrate &&
               toNextSibling &&
               curFromNodeType === TEXT_NODE &&
-              toNextSibling.c__ === TEXT_NODE &&
+              toNextSibling.___nodeType === TEXT_NODE &&
               curFromNodeValue.startsWith(curToNodeValue) &&
               curFromNodeValue.
               slice(curToNodeValue.length).
-              startsWith(toNextSibling.bZ_))
+              startsWith(toNextSibling.___nodeValue))
               {
                 // In hydrate mode we can use splitText to more efficiently handle
                 // adjacent text vdom nodes that were merged.
@@ -643,10 +643,10 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
 
     // We have processed all of the "to nodes".
-    if (fromNode.cs_) {
+    if (fromNode.___finishFragment) {
       // 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.cs_(curFromNodeChild);
+      fromNode.___finishFragment(curFromNodeChild);
     } else {
       // If curFromNodeChild is non-null then we still have some from nodes
       // left over that need to be removed
@@ -659,7 +659,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
         if (fromComponent = componentByDOMNode.get(curFromNodeChild)) {
           curFromNodeChild = fromNextSibling;
           if (
-          !globalComponentsContext.r_[fromComponent.id])
+          !globalComponentsContext.___renderedComponentsById[fromComponent.id])
           {
             destroyComponent(fromComponent);
           }
@@ -675,7 +675,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           referenceComponent = parentComponent;
         } else {
           referenceComponent =
-          curVFromNodeChild && curVFromNodeChild._N_;
+          curVFromNodeChild && curVFromNodeChild.___ownerComponent;
         }
 
         detachNode(curFromNodeChild, fromNode, referenceComponent);
@@ -686,26 +686,26 @@ function morphdom(fromNode, toNode, host, componentsContext) {
   }
 
   function morphEl(fromEl, vFromEl, toEl, parentComponent) {
-    var nodeName = toEl.cg_;
-    var constId = toEl.ci_;
+    var nodeName = toEl.___nodeName;
+    var constId = toEl.___constId;
     vElementByDOMNode.set(fromEl, toEl);
 
-    if (constId !== undefined && vFromEl.ci_ === constId) {
+    if (constId !== undefined && vFromEl.___constId === constId) {
       return;
     }
 
     morphAttrs(fromEl, vFromEl, toEl);
 
-    if (toEl.ad_) {
+    if (toEl.___preserveBody) {
       return;
     }
 
     if (isTextOnly(nodeName)) {
-      if (toEl.ch_ !== vFromEl.ch_) {
+      if (toEl.___textContent !== vFromEl.___textContent) {
         if (nodeName === "textarea") {
-          fromEl.value = toEl.ch_;
+          fromEl.value = toEl.___textContent;
         } else {
-          fromEl.textContent = toEl.ch_;
+          fromEl.textContent = toEl.___textContent;
         }
       }
     } else {
@@ -713,7 +713,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
     }
   } // END: morphEl(...)
 
-  morphChildren(fromNode, toNode, toNode.t_);
+  morphChildren(fromNode, toNode, toNode.___component);
 
   detachedNodes.forEach(function (node) {
     var detachedFromComponent = detachedByDOMNode.get(node);
@@ -730,7 +730,7 @@ function morphdom(fromNode, toNode, host, componentsContext) {
           detachedFromComponent !== true && detachedFromComponent
         );
 
-        if (eventDelegation.ao_(node) != false) {
+        if (eventDelegation.___handleNodeDetach(node) != false) {
           removeChild(node);
         }
       }

package/dist/runtime/vdom/vdom.js

@@ -12,7 +12,7 @@ var specialHtmlRegexp = /[&<]/;
 function virtualizeChildNodes(node, vdomParent, ownerComponent) {
   var curChild = node.firstChild;
   while (curChild) {
-    vdomParent.bR_(virtualize(curChild, ownerComponent));
+    vdomParent.___appendChild(virtualize(curChild, ownerComponent));
     curChild = curChild.nextSibling;
   }
 }
@@ -20,7 +20,7 @@ function virtualizeChildNodes(node, vdomParent, ownerComponent) {
 function virtualize(node, ownerComponent) {
   switch (node.nodeType) {
     case 1:
-      return VElement.ck_(node, virtualizeChildNodes, ownerComponent);
+      return VElement.___virtualize(node, virtualizeChildNodes, ownerComponent);
     case 3:
       return new VText(node.nodeValue, ownerComponent);
     case 8:
@@ -43,7 +43,7 @@ function virtualizeHTML(html, ownerComponent) {
 
   while (curChild) {
     virtualized = virtualize(curChild, ownerComponent);
-    if (virtualized) vdomFragment.bR_(virtualized);
+    if (virtualized) vdomFragment.___appendChild(virtualized);
     curChild = curChild.nextSibling;
   }
 
@@ -70,19 +70,19 @@ Node_prototype.t = function (value) {
     }
   }
 
-  this.bR_(vdomNode || new VText(value.toString()));
-  return this.cj_();
+  this.___appendChild(vdomNode || new VText(value.toString()));
+  return this.___finishChild();
 };
 
-Node_prototype.bW_ = function () {
-  return this.bR_(new VDocumentFragment());
+Node_prototype.___appendDocumentFragment = function () {
+  return this.___appendChild(new VDocumentFragment());
 };
 
-exports.bA_ = VComment;
-exports.bB_ = VDocumentFragment;
-exports.bz_ = VElement;
-exports.bC_ = VText;
-exports.bD_ = VComponent;
-exports.bE_ = VFragment;
-exports.ck_ = virtualize;
-exports.bF_ = virtualizeHTML;
+exports.___VComment = VComment;
+exports.___VDocumentFragment = VDocumentFragment;
+exports.___VElement = VElement;
+exports.___VText = VText;
+exports.___VComponent = VComponent;
+exports.___VFragment = VFragment;
+exports.___virtualize = virtualize;
+exports.___virtualizeHTML = virtualizeHTML;

package/dist/taglib/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
 // eslint-disable-next-line no-constant-binary-expression
-
+let complain = "MARKO_DEBUG" && require("complain");
 const compiler = require("@marko/compiler");
 
 function clearCache() {
@@ -30,13 +30,13 @@ exports.finder = compiler.taglib._finder;
 exports.lookup = {
   buildLookup: function (dir, translator) {
     if (!translator || !Array.isArray(translator.taglibs)) {
-      translator = require("@marko/translator-default");
+      translator = require("../translator");
       // eslint-disable-next-line no-constant-condition
-
-
-
-
-
+      if ("MARKO_DEBUG") {
+        complain(
+          "buildTaglibLookup now requires passing in a transltor as the second argument, eg `buildTaglibLookup(dir, require('marko/translator'))`."
+        );
+      }
     }
 
     return compiler.taglib.buildLookup(dir, translator);

package/dist/translator/cdata/index.js

@@ -0,0 +1,15 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _indexHtml = _interopRequireDefault(require("./index[html]"));
+var _indexVdom = _interopRequireDefault(require("./index[vdom]"));
+
+function _default(path) {
+  const {
+    hub: {
+      file: { markoOpts }
+    }
+  } = path;
+  if (markoOpts.output === "html") {
+    (0, _indexHtml.default)(path);
+  } else {
+    (0, _indexVdom.default)(path);
+  }
+}

package/dist/translator/cdata/index[html].js

@@ -0,0 +1,15 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+
+var _htmlOutWrite = _interopRequireDefault(require("../util/html-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+function _default(path) {
+  const { node } = path;
+
+  path.replaceWith(
+    (0, _withPreviousLocation.default)(
+      (0, _htmlOutWrite.default)`<![CDATA[${_compiler.types.stringLiteral(node.value)}]]>`,
+      node
+    )
+  );
+}

package/dist/translator/cdata/index[vdom].js

@@ -0,0 +1,12 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+
+var _vdomOutWrite = _interopRequireDefault(require("../util/vdom-out-write"));
+var _withPreviousLocation = _interopRequireDefault(require("../util/with-previous-location"));
+
+function _default(path) {
+  const { node } = path;
+
+  path.replaceWith(
+    (0, _withPreviousLocation.default)((0, _vdomOutWrite.default)("t", _compiler.types.stringLiteral(node.value)), node)
+  );
+}

package/dist/translator/class.js

@@ -0,0 +1,65 @@
+"use strict";exports.__esModule = true;exports.default = _default;var _compiler = require("@marko/compiler");
+
+function _default(path) {
+  const {
+    hub: { file },
+    node: {
+      body: { body }
+    }
+  } = path;
+
+  const classProperties = [];
+  let onCreateMethod = body.find(
+    (prop) =>
+    prop.computed === false &&
+    _compiler.types.isIdentifier(prop.key) &&
+    prop.key.name === "onCreate"
+  );
+
+  const objectProperties = body.
+  map((prop) => {
+    if (_compiler.types.isClassMethod(prop)) {
+      prop.type = "ObjectMethod";
+      delete prop.start;
+      delete prop.end;
+      delete prop.loc;
+      return prop;
+    } else if (_compiler.types.isClassProperty(prop) && !prop.static) {
+      if (!prop.declare) {
+        classProperties.push(
+          _compiler.types.assignmentExpression(
+            "=",
+            _compiler.types.memberExpression(_compiler.types.thisExpression(), prop.key, prop.computed),
+            prop.value || _compiler.types.unaryExpression("void", _compiler.types.numericLiteral(0))
+          )
+        );
+      }
+
+      return undefined;
+    }
+
+    throw file.buildCodeFrameError(
+      prop,
+      "Unsupported class property on component."
+    );
+  }).
+  filter(Boolean);
+
+  if (classProperties.length) {
+    if (!onCreateMethod) {
+      objectProperties.push(
+        onCreateMethod = _compiler.types.objectMethod(
+          "method",
+          _compiler.types.identifier("onCreate"),
+          [],
+          _compiler.types.blockStatement([])
+        )
+      );
+    }
+
+    onCreateMethod.body.body.unshift(...classProperties);
+  }
+
+  file._inlineComponentClass = _compiler.types.objectExpression(objectProperties);
+  path.remove();
+}

package/dist/translator/comment/index.js

@@ -0,0 +1,15 @@
+"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.default = _default;var _indexHtml = _interopRequireDefault(require("./index[html]"));
+var _indexVdom = _interopRequireDefault(require("./index[vdom]"));
+
+function _default(path) {
+  const {
+    hub: {
+      file: { markoOpts }
+    }
+  } = path;
+  if (markoOpts.output === "html") {
+    (0, _indexHtml.default)(path);
+  } else {
+    (0, _indexVdom.default)(path);
+  }
+}