@marko/compiler 5.20.6 → 5.20.9

package/dist/babel-plugin/parser.js

@@ -1,10 +1,4 @@
-"use strict";var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");exports.__esModule = true;exports.parseMarko = parseMarko;var _htmljsParser = require("htmljs-parser");
-var _parseAttributes = _interopRequireDefault(require("./util/parse-attributes"));
-var _parseArguments = _interopRequireDefault(require("./util/parse-arguments"));
-var _parseParams = _interopRequireDefault(require("./util/parse-params"));
-var _parseVar = _interopRequireDefault(require("./util/parse-var"));
-var _parseIdShorthand = _interopRequireDefault(require("./util/parse-id-shorthand"));
-var _parseClassnameShorthand = _interopRequireDefault(require("./util/parse-classname-shorthand"));
+"use strict";exports.__esModule = true;exports.parseMarko = parseMarko;var _htmljsParser = require("htmljs-parser");
 var t = _interopRequireWildcard(require("../babel-types"));
 var _babelUtils = require("@marko/babel-utils");function _getRequireWildcardCache(nodeInterop) {if (typeof WeakMap !== "function") return null;var cacheBabelInterop = new WeakMap();var cacheNodeInterop = new WeakMap();return (_getRequireWildcardCache = function (nodeInterop) {return nodeInterop ? cacheNodeInterop : cacheBabelInterop;})(nodeInterop);}function _interopRequireWildcard(obj, nodeInterop) {if (!nodeInterop && obj && obj.__esModule) {return obj;}if (obj === null || typeof obj !== "object" && typeof obj !== "function") {return { default: obj };}var cache = _getRequireWildcardCache(nodeInterop);if (cache && cache.has(obj)) {return cache.get(obj);}var newObj = {};var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;for (var key in obj) {if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;if (desc && (desc.get || desc.set)) {Object.defineProperty(newObj, key, desc);} else {newObj[key] = obj[key];}}}newObj.default = obj;if (cache) {cache.set(obj, newObj);}return newObj;}
 
@@ -12,356 +6,475 @@ var _babelUtils = require("@marko/babel-utils");function _getRequireWildcardCach
 
 
 
+const noop = () => {};
+const emptyRange = (part) => part.start === part.end;
+const isAttrTag = (tag) => {var _tag$name$value;return ((_tag$name$value = tag.name.value) == null ? void 0 : _tag$name$value[0]) === "@";};
+const toBabelPosition = ({ line, character }) => ({
+  line: line + 1,
+  column: character ? character - 1 : character });
 
 
-
-const EMPTY_OBJECT = {};
-const EMPTY_ARRAY = [];
-const htmlTrimStart = (t) => t.replace(/^[\n\r]\s*/, "");
-const htmlTrimEnd = (t) => t.replace(/[\n\r]\s*$/, "");
-const htmlTrim = (t) => htmlTrimStart(htmlTrimEnd(t));
-const isAttributeTag = (node) =>
-t.isStringLiteral(node.name) && node.name.value[0] === "@";
-
 function parseMarko(file) {
   const { code } = file;
   const { htmlParseOptions = {} } = file.markoOpts;
   const { watchFiles } = file.metadata.marko;
-  const pushTagBody = (node) => getTagBody().pushContainer("body", node);
-  const getTagBody = () =>
-  currentTag.isProgram() ? currentTag : currentTag.get("body");
-  let { preserveWhitespace } = htmlParseOptions;
   let currentTag = file.path;
+  let currentBody = currentTag;
+  let currentAttr = undefined;
+  let currentShorthandId = undefined;
+  let currentShorthandClassNames = undefined;
+  let { preserveWhitespace } = htmlParseOptions;
   let preservingWhitespaceUntil = preserveWhitespace;
-  let wasSelfClosing = false;
-  let handledTagName = false;
-  let onNext;
-
-  const handlers = {
-    onDocumentType({ value, pos, endPos }) {
-      const node = (0, _babelUtils.withLoc)(file, t.markoDocumentType(value), pos, endPos);
-      pushTagBody(node);
-      /* istanbul ignore next */
-      onNext = onNext && onNext(node);
-    },
+  let onNext = noop;
+  const positionAt = (index) => toBabelPosition(parser.positionAt(index));
+  const locationAt = (range) => {
+    // Babel columns start at 0, but that is silly.
+    // Here we normalize the parsers 1 based columns.
+    const { start, end } = parser.locationAt(range);
+    return {
+      start: toBabelPosition(start),
+      end: toBabelPosition(end) };
+
+  };
+  const withLoc = (node, range) => {
+    node.start = range.start;
+    node.end = range.end;
+    node.loc = locationAt(range);
+    return node;
+  };
+  const enterTag = (node) => {
+    currentTag = currentBody.pushContainer("body", node)[0];
+    currentBody = currentTag.get("body");
+    onNext(node);
+  };
+  const pushContent = (node) => {
+    currentBody.node.body.push(node);
+    onNext(node);
+  };
+  const endAttr = () => {
+    if (currentAttr) {
+      currentAttr.loc = locationAt(currentAttr);
+      currentAttr = undefined;
+    }
+  };
+  const parseTemplateString = ({ quasis, expressions }) => {
+    switch (expressions.length) {
+      case 0:{
+          const [first] = quasis;
+          return withLoc(t.stringLiteral(parser.read(first)), first);
+        }
+      case 1:{
+          if (emptyRange(quasis[0]) && emptyRange(quasis[1])) {
+            const [{ value }] = expressions;
+            const result = (0, _babelUtils.parseExpression)(file, parser.read(value), value.start);
+            if (t.isStringLiteral(result)) {
+              // convert to template literal just so that we don't mistake it for a native tag if this is a tag name.
+              return t.templateLiteral(
+              [
+              t.templateElement({
+                raw: result.value,
+                cooked: result.value })],
+
+
+              []);
+
+            } else {
+              return result;
+            }
+          }
+        }}
 
-    onDeclaration({ value, pos, endPos }) {
-      const node = (0, _babelUtils.withLoc)(file, t.markoDeclaration(value), pos, endPos);
-      pushTagBody(node);
-      /* istanbul ignore next */
-      onNext = onNext && onNext(node);
-    },
 
-    onComment({ value, pos, endPos }) {
-      const node = (0, _babelUtils.withLoc)(file, t.markoComment(value), pos, endPos);
-      pushTagBody(node);
-      onNext = onNext && onNext(node);
-    },
+    const [{ start }] = quasis;
+    const end = quasis[quasis.length - 1].end;
+    return (0, _babelUtils.parseExpression)(
+    file,
+    `\`${parser.read({ start, end })}\``,
+    start - 1);
+
+  };
 
-    onCDATA({ value, pos, endPos }) {
-      const node = (0, _babelUtils.withLoc)(file, t.markoCDATA(value), pos, endPos);
-      pushTagBody(node);
-      onNext = onNext && onNext(node);
+  const parser = (0, _htmljsParser.createParser)({
+    onError(part) {
+      throw file.buildCodeFrameError({ loc: locationAt(part) }, part.message);
     },
+    onText(part) {var _prev;
+      const rawValue = parser.read(part);
 
-    onText({ value }, parser) {
-      const shouldTrim = !preservingWhitespaceUntil;
-      const { body } = getTagBody().node;
-      let pos = parser.pos - value.length;
+      if (preservingWhitespaceUntil) {
+        pushContent(withLoc(t.markoText(rawValue), part));
+        return;
+      }
 
-      if (shouldTrim) {
-        if (htmlTrim(value) === "") {
-          return;
-        }
+      if (/^(?:[\n\r]\s*)?(?:[\n\r]\s*)?$/.test(rawValue)) return;
 
-        // Find previous non-scriptlet/@tag.
-        let prev;
-        let prevIndex = body.length;
-        while (prevIndex > 0) {
-          prev = body[--prevIndex];
-
-          if (
-          t.isMarkoClass(prev) ||
-          t.isMarkoComment(prev) ||
-          t.isMarkoScriptlet(prev) ||
-          isAttributeTag(prev))
-          {
-            prev = undefined;
-          } else {
-            break;
-          }
-        }
+      const { body } = currentBody.node;
+      let prev;
+      let prevIndex = body.length;
+      // Find previous non-scriptlet or comment.
+      while (prevIndex > 0) {
+        prev = body[--prevIndex];
 
-        if (!prev) {
-          const originalValue = value;
-          value = htmlTrimStart(value);
-          pos += originalValue.indexOf(value);
-        } else if (
-        t.isMarkoText(prev) &&
-        /\s/.test(prev.value[prev.value.length - 1]))
-        {
-          const originalValue = value;
-          value = value.replace(/^\s+/, "");
-          pos += originalValue.indexOf(value);
+        if (t.isMarkoScriptlet(prev) || t.isMarkoComment(prev)) {
+          prev = undefined;
+        } else {
+          break;
         }
       }
 
-      const endPos = pos + value.length;
-      const node = (0, _babelUtils.withLoc)(file, t.markoText(value), pos, endPos);
-      const prevBody = getTagBody().node.body;
-      pushTagBody(node);
-      onNext && onNext(node);
-      onNext =
-      shouldTrim && (
-      (next) => {
-        if (!next || prevBody.indexOf(next) === -1) {
-          node.value = htmlTrimEnd(node.value);
-        }
+      let value = rawValue;
+      switch ((_prev = prev) == null ? void 0 : _prev.type) {
+        case "MarkoPlaceholder":
+          break;
+        case "MarkoText":
+          if (/\s$/.test(prev.value)) {
+            value = value.replace(/^\s+/, "");
+          }
+          break;
+        case "MarkoTag":
+          if (isAttrTag(prev)) {
+            value = value.replace(/^[\n\r]\s*/, "");
+          }
+          break;
+        default:
+          value = value.replace(/^[\n\r]\s*/, "");
+          break;}
+
+
+      const node = t.markoText(value);
+      pushContent(node);
+      onNext = (next) => {
+        switch (next == null ? void 0 : next.type) {
+          case "MarkoScriptlet":
+          case "MarkoComment":
+            return;
+          case "MarkoPlaceholder":
+            break;
+          case "MarkoText":
+            if (/^\s/.test(next.value)) {
+              value = value.replace(/\s+$/, "");
+            }
+            break;
+          case "MarkoTag":
+            if (isAttrTag(next)) {
+              value = value.replace(/[\n\r]\s*$/, "");
+            }
 
-        node.value = node.value.replace(/\s+/g, " ");
-      });
-    },
+            break;
+          default:
+            value = value.replace(/[\n\r]\s*$/, "");
+            break;}
 
-    onPlaceholder({ escape, value, withinBody, pos, endPos }) {
-      if (withinBody) {
-        const node = (0, _babelUtils.withLoc)(
-        file,
-        t.markoPlaceholder(
-        (0, _babelUtils.parseExpression)(
-        file,
-        value,
-        pos + (escape ? 2 /* ${ */ : 3) /* $!{ */),
 
-        escape),
+        node.value = value.replace(/\s+/g, " ");
 
-        pos,
-        endPos);
+        if (node.value) {
+          const trimmedStart = part.start + rawValue.indexOf(value);
+          withLoc(node, {
+            start: trimmedStart,
+            end: trimmedStart + rawValue.length });
 
+        } else {
+          body.splice(body.indexOf(node), 1);
+        }
 
-        pushTagBody(node);
-        onNext = onNext && onNext(node);
-      }
+        onNext = noop;
+      };
+    },
+    onCDATA(part) {
+      pushContent(withLoc(t.markoCDATA(parser.read(part.value)), part));
+    },
+    onDoctype(part) {
+      pushContent(withLoc(t.markoDocumentType(parser.read(part.value)), part));
+    },
+    onDeclaration(part) {
+      pushContent(withLoc(t.markoDeclaration(parser.read(part.value)), part));
     },
+    onComment(part) {
+      pushContent(withLoc(t.markoComment(parser.read(part.value)), part));
+    },
+    onPlaceholder(part) {
+      pushContent(
+      withLoc(
+      t.markoPlaceholder(
+      (0, _babelUtils.parseExpression)(file, parser.read(part.value), part.value.start),
+      part.escape),
 
-    onScriptlet({ value, line, block, pos, endPos }) {
-      if (!line && !block) {
-        throw file.buildCodeFrameError(
-        { loc: (0, _babelUtils.getLocRange)(file, pos, endPos) },
-        "<% scriptlets %> are no longer supported.");
+      part));
 
-      }
 
-      pos -= 1; // Include $.
-      // Scriptlets are ignored as content and don't call `onNext`.
-      pushTagBody(
-      (0, _babelUtils.withLoc)(
-      file,
+    },
+    onScriptlet(part) {
+      pushContent(
+      withLoc(
       t.markoScriptlet(
-      (0, _babelUtils.parseScript)(file, value, pos + 2 /** Ignores leading `$ ` */).body),
+      (0, _babelUtils.parseScript)(file, parser.read(part.value), part.value.start).body),
 
-      pos,
-      endPos));
+      part));
 
 
     },
+    onTagName(part) {
+      const tagName = parseTemplateString(part);
+      const node = t.markoTag(tagName, [], t.markoTagBody());
+      let parseType = _htmljsParser.TagType.html;
+      node.start = part.start - (part.concise ? 0 : 1); // Account for leading `<`.
+      node.end = part.end;
 
-    onOpenTagName(event) {
-      const { pos, endPos } = event;
-      const tagName = event.tagName || "div";
-      const [, tagNameExpression] =
-      /^\$\{([\s\S]*)\}/.exec(tagName) || EMPTY_ARRAY;
-      const tagDef = !tagNameExpression && (0, _babelUtils.getTagDefForTagName)(file, tagName);
-      const tagNameStartPos = pos + (event.concise ? 0 : 1); // Account for leading `<`.
-
-      handledTagName = true;
-
-      if (tagNameExpression === "") {
-        throw file.buildCodeFrameError(
-        { loc: (0, _babelUtils.getLocRange)(file, tagNameStartPos + 1, tagNameStartPos + 3) },
-        "Missing expression for <${dynamic}> tag.");
+      if (t.isStringLiteral(tagName)) {var _node$tagDef;
+        const literalTagName = tagName.value || (tagName.value = "div");
 
-      }
+        if (literalTagName === "%") {
+          throw file.buildCodeFrameError(
+          tagName,
+          "<% scriptlets %> are no longer supported.");
 
-      let tagNameNode;
+        }
 
-      if (tagNameExpression) {
-        tagNameNode = (0, _babelUtils.parseExpression)(
+        const parseOptions = (_node$tagDef = node.tagDef = (0, _babelUtils.getTagDefForTagName)(
         file,
-        tagNameExpression,
-        tagNameStartPos + 2 /* ${ */);
-
+        literalTagName)) == null ? void 0 : _node$tagDef.
+        parseOptions;
 
-        if (t.isStringLiteral(tagNameNode)) {
-          // convert to template literal just so that we don't mistake it for a native tag.
-          tagNameNode = t.templateLiteral(
-          [
-          t.templateElement({
-            raw: tagNameNode.value,
-            cooked: tagNameNode.value })],
-
-
-          []);
+        if (parseOptions) {
+          if (parseOptions.preserveWhitespace) {
+            preservingWhitespaceUntil = node;
+          }
 
+          if (parseOptions.statement) {
+            parseType = _htmljsParser.TagType.statement;
+          } else if (parseOptions.openTagOnly) {
+            parseType = _htmljsParser.TagType.void;
+          } else if (parseOptions.text) {
+            parseType = _htmljsParser.TagType.text;
+          }
         }
-      } else {
-        tagNameNode = (0, _babelUtils.withLoc)(
-        file,
-        t.stringLiteral(tagName),
-        tagNameStartPos,
-        tagNameStartPos + tagName.length);
+      }
 
+      enterTag(node);
+      return parseType;
+    },
+    onTagShorthandId(part) {
+      currentShorthandId = parseTemplateString(part);
+    },
+    onTagShorthandClass(part) {
+      if (currentShorthandClassNames) {
+        currentShorthandClassNames.push(parseTemplateString(part));
+      } else {
+        currentShorthandClassNames = [parseTemplateString(part)];
       }
+    },
 
-      const node = (0, _babelUtils.withLoc)(
+    onTagVar(part) {
+      currentTag.node.var = (0, _babelUtils.parseExpression)(
       file,
-      t.markoTag(tagNameNode, [], t.markoTagBody()),
-      pos,
-      endPos);
+      `${parser.read(part.value)}=1`,
+      part.value.start).
+      left;
+    },
 
+    onTagParams(part) {
+      currentTag.node.body.params = (0, _babelUtils.parseExpression)(
+      file,
+      `(${parser.read(part.value)})=>{}`,
+      part.start).
+      params;
+    },
 
-      if (tagDef) {
-        node.tagDef = tagDef;
+    onTagArgs(part) {
+      currentTag.node.arguments = (0, _babelUtils.parseExpression)(
+      file,
+      `_${parser.read(part)}`,
+      part.start - 1).
+      arguments;
+    },
 
-        const { parseOptions } = tagDef;
-        if (parseOptions) {
-          event.setParseOptions(parseOptions);
+    onAttrName(part) {
+      const [, name, modifier] = /^([^:]*)(?::(.*))?/.exec(parser.read(part));
+      endAttr();
+      currentTag.node.attributes.push(
+      currentAttr = t.markoAttribute(
+      name || "default",
+      t.booleanLiteral(true),
+      modifier,
+      undefined,
+      !name));
 
-          if (parseOptions.rootOnly && !currentTag.isProgram()) {
-            throw file.buildCodeFrameError(
-            { loc: (0, _babelUtils.getLocRange)(file, pos, endPos) },
-            `"${tagName}" tags must be at the root of your Marko template.`);
 
-          }
-        }
-      }
 
-      [currentTag] = pushTagBody(node);
-
-      // @tags are not treated as content and do not call next.
-      if (!isAttributeTag(node)) {
-        onNext = onNext && onNext(node);
-      }
+      currentAttr.start = part.start;
+      currentAttr.end = part.end;
     },
 
-    onOpenTag(event, parser) {
-      if (!handledTagName) {
-        // There is a bug in htmljs parser where a single top level concise mode tag with nothing else
-        // does not emit the openTagNameEvent.
-        handlers.onOpenTagName(event);
-      }
-
-      handledTagName = false;
-      const { pos, endPos, tagNameEndPos } = event;
-      const { tagDef } = currentTag.node;
-      const parseOptions = tagDef && tagDef.parseOptions || EMPTY_OBJECT;
-      wasSelfClosing = event.selfClosed;
+    onAttrArgs(part) {
+      currentAttr.arguments = (0, _babelUtils.parseExpression)(
+      file,
+      `_${parser.read(part)}`,
+      part.start - 1).
+      arguments;
+      currentAttr.end = part.end;
+    },
 
-      if (parseOptions.state === "parsed-text") {
-        parser.enterParsedTextContentState();
-      } else if (parseOptions.state === "static-text") {
-        parser.enterStaticTextContentState();
-      }
+    onAttrValue(part) {
+      currentAttr.end = part.end;
+      currentAttr.bound = part.bound;
+      currentAttr.value = (0, _babelUtils.parseExpression)(
+      file,
+      parser.read(part.value),
+      part.value.start);
 
-      if (parseOptions.rawOpenTag) {
-        currentTag.set(
-        "rawValue",
-        parser.substring(pos, endPos).replace(/^<|\/>$|>$/g, ""));
+    },
 
-      }
+    onAttrMethod(part) {
+      const prefix = "function";
+      currentAttr.end = part.end;
+      currentAttr.value = (0, _babelUtils.parseExpression)(
+      file,
+      prefix + parser.read(part),
+      part.start - prefix.length);
 
-      if (!parseOptions.ignoreAttributes) {
-        currentTag.set("var", (0, _parseVar.default)(file, event.var));
-        currentTag.get("body").set("params", (0, _parseParams.default)(file, event.params));
-        currentTag.set("arguments", (0, _parseArguments.default)(file, event.argument));
-        currentTag.set(
-        "attributes",
-        (0, _parseIdShorthand.default)(
-        file,
-        event.shorthandId,
-        (0, _parseClassnameShorthand.default)(
-        file,
-        event.shorthandClassNames,
-        (0, _parseAttributes.default)(file, event.attributes, tagNameEndPos))));
+    },
 
+    onAttrSpread(part) {
+      endAttr();
+      currentTag.node.attributes.push(
+      withLoc(
+      t.markoSpreadAttribute(
+      (0, _babelUtils.parseExpression)(file, parser.read(part.value), part.value.start)),
 
+      part));
 
-      }
 
-      if (!preservingWhitespaceUntil && parseOptions.preserveWhitespace) {
-        preservingWhitespaceUntil = currentTag;
-      }
     },
 
-    onCloseTag(event, parser) {
-      let { pos, endPos } = event;
-      const tag = currentTag;
-      const { node } = tag;
-      const { tagDef } = node;
-      const isConcise = code[node.start - 1] !== "<";
+    onOpenTagEnd(part) {var _node$tagDef2;
+      const { node } = currentTag;
+      const { attributes } = node;
+      const parseOptions = (_node$tagDef2 = node.tagDef) == null ? void 0 : _node$tagDef2.parseOptions;
+      endAttr();
+
+      if (currentShorthandClassNames) {
+        let foundClassAttr = false;
+        const classShorthandValue =
+        currentShorthandClassNames.length === 1 ?
+        currentShorthandClassNames[0] :
+        currentShorthandClassNames.every((expr) => t.isStringLiteral(expr)) ?
+        withLoc(
+        t.stringLiteral(
+        currentShorthandClassNames.map((node) => node.value).join(" ")),
 
-      if (preservingWhitespaceUntil === currentTag) {
-        preservingWhitespaceUntil = undefined;
-      }
+        {
+          start: currentShorthandClassNames[0].start,
+          end: currentShorthandClassNames[
+          currentShorthandClassNames.length - 1].
+          end }) :
+
+
+        t.arrayExpression(currentShorthandClassNames);
+
+        for (const attr of attributes) {
+          if (attr.name === "class") {
+            foundClassAttr = true;
+            if (t.isArrayExpression(attr.value)) {
+              if (t.isArrayExpression(classShorthandValue)) {
+                attr.value.elements.push(...classShorthandValue.elements);
+              } else {
+                attr.value.elements.push(classShorthandValue);
+              }
+            } else if (
+            t.isStringLiteral(attr.value) &&
+            t.isStringLiteral(classShorthandValue))
+            {
+              attr.value.value = `${classShorthandValue.value} ${attr.value.value}`;
+            } else if (t.isArrayExpression(classShorthandValue)) {
+              classShorthandValue.elements.push(attr.value);
+              attr.value = classShorthandValue;
+            } else {
+              attr.value = t.arrayExpression([classShorthandValue, attr.value]);
+            }
+            break;
+          }
+        }
 
-      if (!pos) {
-        pos = parser.pos;
+        if (!foundClassAttr) {
+          attributes.push(t.markoAttribute("class", classShorthandValue));
+        }
+
+        currentShorthandClassNames = undefined;
       }
 
-      if (!endPos) {
-        endPos = pos;
+      if (currentShorthandId) {
+        for (const attr of attributes) {
+          if (attr.name === "id") {
+            throw file.buildCodeFrameError(
+            attr,
+            "Cannot have shorthand id and id attribute.");
 
-        if (wasSelfClosing && !isConcise) {
-          endPos += 2; // account for "/>"
+          }
         }
+        currentTag.node.attributes.push(
+        t.markoAttribute("id", currentShorthandId));
+
+        currentShorthandId = undefined;
       }
 
-      node.end = endPos;
-      node.loc.end = (0, _babelUtils.getLoc)(file, endPos);
+      if (parseOptions) {
+        if (parseOptions.rawOpenTag) {
+          node.rawValue = parser.read({
+            start: node.name.start,
+            end: part.start });
 
-      if (
-      !isConcise &&
-      !wasSelfClosing &&
-      code[pos + 1] !== "/" &&
-      !currentTag.get("name").isStringLiteral())
-      {
-        throw file.buildCodeFrameError(
-        { loc: (0, _babelUtils.getLocRange)(file, pos, endPos) },
-        `Invalid ending for dynamic tag, expected "</>".`);
+        }
 
+        if (
+        part.selfClosed ||
+        parseOptions.statement ||
+        parseOptions.openTagOnly)
+        {
+          this.onCloseTag(part);
+        }
+      } else if (part.selfClosed) {
+        this.onCloseTag(part);
+      }
+    },
+    onCloseTag(part) {var _node$tagDef3;
+      const { node } = currentTag;
+      const parserPlugin = (_node$tagDef3 = node.tagDef) == null ? void 0 : _node$tagDef3.parser;
+      if (preservingWhitespaceUntil === node) {
+        preservingWhitespaceUntil = undefined;
       }
 
-      if (tagDef && tagDef.parser) {
-        if (tagDef.parser.path) {
-          watchFiles.push(tagDef.parser.path);
-        }
-        /* istanbul ignore next */
-        (tagDef.parser.hook.default || tagDef.parser.hook)(tag, t);
+      node.end = part.end;
+      node.loc = locationAt(node);
+
+      if (parserPlugin) {
+        const { hook } = parserPlugin;
+        if (parserPlugin.path) watchFiles.push(parserPlugin.path);
+        (hook.default || hook)(currentTag, t);
       }
 
-      currentTag = currentTag.parentPath.parentPath || file.path;
-    },
+      currentTag = currentTag.parentPath.parentPath;
 
-    onfinish() {
-      onNext = onNext && onNext();
-    },
+      if (currentTag) {
+        currentBody = currentTag.get("body");
+      } else {
+        currentTag = currentBody = file.path;
+      }
 
-    onError({ message, pos, endPos }) {
-      if (message.includes("EOF")) endPos = pos;
-      throw file.buildCodeFrameError(
-      { loc: (0, _babelUtils.getLocRange)(file, pos, endPos) },
-      message);
+      onNext();
+    } });
 
-    } };
 
+  parser.parse(code);
+  onNext();
+
+  const { ast } = file;
+  const { program } = ast;
+  ast.start = program.start = 0;
+  ast.end = program.end = code.length - 1;
+  ast.loc = program.loc = {
+    start: { line: 1, column: 0 },
+    end: positionAt(ast.end) };
 
-  (0, _htmljsParser.createParser)(handlers, {
-    isOpenTagOnly(name) {
-      const { parseOptions = EMPTY_OBJECT } =
-      (0, _babelUtils.getTagDefForTagName)(file, name) || EMPTY_OBJECT;
-      return parseOptions.openTagOnly;
-    },
-    ignoreNonstandardStringPlaceholders: true,
-    ...htmlParseOptions }).
-  parse(code, file.opts.filename);
 }
 //# sourceMappingURL=parser.js.map