prettier-plugin-astro 0.0.10 → 0.1.0-next.0

package/dist/index.js

@@ -2,44 +2,27 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var parser = require('@astrojs/parser');
+var makeSynchronous = require('make-synchronous');
 var _doc = require('prettier/doc');
 var sassFormatter = require('sass-formatter');
-var prettier = require('prettier');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
+var makeSynchronous__default = /*#__PURE__*/_interopDefaultLegacy(makeSynchronous);
 var _doc__default = /*#__PURE__*/_interopDefaultLegacy(_doc);
 
-const parse = (text) => parser.parse(text);
-
-const options = {
-    astroSortOrder: {
-        since: '0.0.1',
-        category: 'Astro',
-        type: 'choice',
-        default: 'markup | styles',
-        description: 'Sort order for markup, scripts, and styles',
-        choices: [
-            {
-                value: 'markup | styles',
-                description: 'markup | styles',
-            },
-            {
-                value: 'styles | markup',
-                description: 'styles | markup',
-            },
-        ],
-    },
-    astroAllowShorthand: {
-        since: '0.0.10',
-        category: 'Astro',
-        type: 'boolean',
-        default: true,
-        description: 'Enable/disable attribute shorthand if attribute name and expression are the same',
-    },
-};
-const parseSortOrder = (sortOrder) => sortOrder.split(' | ');
+const parseSync = makeSynchronous__default["default"](async (source) => {
+    const dynamicImport = new Function('file', 'return import(file)');
+    const { parse } = await dynamicImport('@astrojs/compiler');
+    try {
+        const { ast } = await parse(source);
+        return ast;
+    }
+    catch (e) {
+        console.error(e);
+    }
+});
+const parse = (text) => parseSync(text);
 
 const blockElementsT = [
     'address',
@@ -75,70 +58,48 @@ const blockElementsT = [
     'section',
     'table',
     'ul',
+    'title',
+    'html',
 ];
 const blockElements = [...blockElementsT];
 const selfClosingTags = ['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'];
 
+const serializeSync = makeSynchronous__default["default"](async (node) => {
+    const dynamicImport = new Function('file', 'return import(file)');
+    const { serialize } = await dynamicImport('@astrojs/compiler/utils');
+    try {
+        return await serialize(node);
+    }
+    catch (e) {
+        console.error(e);
+    }
+});
+const serialize = (node) => serializeSync(node);
+
 const formattableAttributes = [];
-const rootNodeKeys = new Set(['html', 'css', 'module']);
-const isASTNode = (node) => typeof node === 'object' && Object.keys(node).filter((key) => rootNodeKeys.has(key)).length === rootNodeKeys.size;
 const isEmptyTextNode = (node) => {
-    return !!node && node.type === 'Text' && getUnencodedText(node).trim() === '';
+    return !!node && node.type === 'text' && getUnencodedText(node).trim() === '';
 };
 const isPreTagContent = (path) => {
     if (!path || !path.stack || !Array.isArray(path.stack))
         return false;
-    return path.stack.some((node) => (node.type === 'Element' && node.name.toLowerCase() === 'pre') || (node.type === 'Attribute' && !formattableAttributes.includes(node.name)));
+    return path.stack.some((node) => (node.type === 'element' && node.name.toLowerCase() === 'pre') || (node.type === 'attribute' && !formattableAttributes.includes(node.name)));
 };
-function isLoneMustacheTag(node) {
-    return node !== true && node.length === 1 && node[0].type === 'MustacheTag';
-}
-function isAttributeShorthand(node) {
-    return node !== true && node.length === 1 && node[0].type === 'AttributeShorthand';
-}
-function isOrCanBeConvertedToShorthand(node, opts) {
-    if (!opts.astroAllowShorthand)
-        return false;
-    if (isAttributeShorthand(node.value)) {
-        return true;
-    }
-    if (isLoneMustacheTag(node.value)) {
-        const expression = node.value[0].expression;
-        return expression.codeChunks[0] === node.name;
-    }
-    return false;
-}
 function getText(node, opts) {
-    return opts.originalText.slice(opts.locStart(node), opts.locEnd(node));
+    var _a, _b, _c;
+    return opts.originalText.slice(((_a = node.position) === null || _a === void 0 ? void 0 : _a.start.offset) + 1, (_c = (_b = node.position) === null || _b === void 0 ? void 0 : _b.end) === null || _c === void 0 ? void 0 : _c.offset);
 }
 function getUnencodedText(node) {
-    return node.raw || node.data;
+    return node.value;
 }
-function replaceEndOfLineWith(text, replacement) {
-    const parts = [];
-    for (const part of text.split('\n')) {
-        if (parts.length > 0) {
-            parts.push(replacement);
-        }
-        if (part.endsWith('\r')) {
-            parts.push(part.slice(0, -1));
-        }
-        else {
-            parts.push(part);
-        }
-    }
-    return parts;
-}
-function printRaw(node, originalText, stripLeadingAndTrailingNewline = false) {
+function printRaw(node, stripLeadingAndTrailingNewline = false) {
     if (!isNodeWithChildren(node)) {
         return '';
     }
     if (node.children.length === 0) {
         return '';
     }
-    const firstChild = node.children[0];
-    const lastChild = node.children[node.children.length - 1];
-    let raw = originalText.substring(firstChild.start, lastChild.end);
+    let raw = node.children.reduce((prev, curr) => prev + serialize(curr), '');
     if (!stripLeadingAndTrailingNewline) {
         return raw;
     }
@@ -157,10 +118,10 @@ function isNodeWithChildren(node) {
     return node && Array.isArray(node.children);
 }
 function isInlineElement(path, opts, node) {
-    return node && node.type === 'Element' && !isBlockElement(node, opts) && !isPreTagContent(path);
+    return node && node.type === 'element' && !isBlockElement(node, opts) && !isPreTagContent(path);
 }
 function isBlockElement(node, opts) {
-    return node && node.type === 'Element' && opts.htmlWhitespaceSensitivity !== 'strict' && (opts.htmlWhitespaceSensitivity === 'ignore' || blockElements.includes(node.name));
+    return node && node.type === 'element' && opts.htmlWhitespaceSensitivity !== 'strict' && (opts.htmlWhitespaceSensitivity === 'ignore' || blockElements.includes(node.name));
 }
 function isTextNodeStartingWithLinebreak(node, nrLines = 1) {
     return startsWithLinebreak(getUnencodedText(node), nrLines);
@@ -172,10 +133,10 @@ function endsWithLinebreak(text, nrLines = 1) {
     return new RegExp(`(\\n[\\t\\f\\r ]*){${nrLines}}$`).test(text);
 }
 function isTextNodeStartingWithWhitespace(node) {
-    return node.type === 'Text' && /^\s/.test(getUnencodedText(node));
+    return node.type === 'text' && /^\s/.test(getUnencodedText(node));
 }
 function isTextNodeEndingWithWhitespace(node) {
-    return node.type === 'Text' && /\s$/.test(getUnencodedText(node));
+    return node.type === 'text' && /\s$/.test(getUnencodedText(node));
 }
 function forceIntoExpression(statement) {
     return `(${statement}\n)`;
@@ -205,8 +166,7 @@ function shouldHugEnd(node, opts) {
     if (children.length === 0) {
         return true;
     }
-    const lastChild = children[children.length - 1];
-    return !isTextNodeEndingWithWhitespace(lastChild);
+    return false;
 }
 function canOmitSoftlineBeforeClosingTag(path, opts) {
     return isLastChildWithinParentBlockElement(path, opts);
@@ -224,179 +184,49 @@ function isLastChildWithinParentBlockElement(path, opts) {
     return lastChild === path.getNode();
 }
 function trimTextNodeLeft(node) {
-    node.raw = node.raw && node.raw.trimLeft();
-    node.data = node.data && node.data.trimLeft();
+    node.value = node.value && node.value.trimStart();
 }
 function trimTextNodeRight(node) {
-    node.raw = node.raw && node.raw.trimRight();
-    node.data = node.data && node.data.trimRight();
-}
-function findLastIndex(isMatch, items) {
-    for (let i = items.length - 1; i >= 0; i--) {
-        if (isMatch(items[i], i)) {
-            return i;
-        }
-    }
-    return -1;
-}
-function trimChildren(children) {
-    let firstNonEmptyNode = children.findIndex((n) => !isEmptyTextNode(n));
-    firstNonEmptyNode = firstNonEmptyNode === -1 ? children.length - 1 : firstNonEmptyNode;
-    let lastNonEmptyNode = findLastIndex((n, idx) => {
-        return !isEmptyTextNode(n);
-    }, children);
-    lastNonEmptyNode = lastNonEmptyNode === -1 ? 0 : lastNonEmptyNode;
-    for (let i = 0; i <= firstNonEmptyNode; i++) {
-        const n = children[i];
-        if (isTextNode(n)) {
-            trimTextNodeLeft(n);
-        }
-    }
-    for (let i = children.length - 1; i >= lastNonEmptyNode; i--) {
-        const n = children[i];
-        if (isTextNode(n)) {
-            trimTextNodeRight(n);
-        }
-    }
-}
-function isHardline(docToCheck) {
-    return docToCheck === prettier.doc.builders.hardline || deepEqual(docToCheck, prettier.doc.builders.hardline);
-}
-function deepEqual(x, y) {
-    if (x === y) {
-        return true;
-    }
-    else if (typeof x == 'object' && x != null && typeof y == 'object' && y != null) {
-        if (Object.keys(x).length != Object.keys(y).length)
-            return false;
-        for (var prop in x) {
-            if (Object.prototype.hasOwnProperty.call(y, prop)) {
-                if (!deepEqual(x[prop], y[prop]))
-                    return false;
+    node.value = node.value && node.value.trimEnd();
+}
+function manualDedent(input) {
+    let result = '';
+    for (var i = 0; i < input.length; i++) {
+        result += input[i]
+            .replace(/\\\n[ \t]*/g, '')
+            .replace(/\\`/g, '`');
+        if (i < (arguments.length <= 1 ? 0 : arguments.length - 1)) {
+            result += arguments.length <= i + 1 ? undefined : arguments[i + 1];
+        }
+    }
+    const lines = result.split('\n');
+    let mindent = null;
+    lines.forEach(function (l) {
+        var m = l.match(/^(\s+)\S+/);
+        if (m) {
+            var indent = m[1].length;
+            if (!mindent) {
+                mindent = indent;
             }
             else {
-                return false;
-            }
-        }
-        return true;
-    }
-    else {
-        return false;
-    }
-}
-function isLine(docToCheck) {
-    return (isHardline(docToCheck) ||
-        (typeof docToCheck === 'object' && isDocCommand(docToCheck) && docToCheck.type === 'line') ||
-        (typeof docToCheck === 'object' && isDocCommand(docToCheck) && docToCheck.type === 'concat' && docToCheck.parts.every(isLine)));
-}
-function isEmptyDoc(doc) {
-    if (typeof doc === 'string') {
-        return doc.length === 0;
-    }
-    if (Array.isArray(doc)) {
-        return doc.length === 0;
-    }
-    return false;
-}
-function trim(docs, isWhitespace) {
-    trimLeft(docs, isWhitespace);
-    trimRight(docs, isWhitespace);
-    return docs;
-}
-function trimLeft(group, isWhitespace) {
-    let firstNonWhitespace = group.findIndex((doc) => !isEmptyDoc(doc) && !isWhitespace(doc));
-    if (firstNonWhitespace < 0 && group.length) {
-        firstNonWhitespace = group.length;
-    }
-    if (firstNonWhitespace > 0) {
-        const removed = group.splice(0, firstNonWhitespace);
-        if (removed.every(isEmptyDoc)) {
-            return trimLeft(group, isWhitespace);
-        }
-    }
-    else {
-        const parts = getParts(group[0]);
-        if (parts) {
-            return trimLeft(parts, isWhitespace);
-        }
-    }
-}
-function trimRight(group, isWhitespace) {
-    let lastNonWhitespace = group.length ? findLastIndex((doc) => !isEmptyDoc(doc) && !isWhitespace(doc), group) : 0;
-    if (lastNonWhitespace < group.length - 1) {
-        const removed = group.splice(lastNonWhitespace + 1);
-        if (removed.every(isEmptyDoc)) {
-            return trimRight(group, isWhitespace);
-        }
-    }
-    else {
-        const parts = getParts(group[group.length - 1]);
-        if (parts) {
-            return trimRight(parts, isWhitespace);
-        }
-    }
-}
-function getParts(doc) {
-    if (typeof doc === 'object') {
-        if (Array.isArray(doc)) {
-            return doc;
-        }
-        if (doc.type === 'fill' || doc.type === 'concat') {
-            return doc.parts;
-        }
-        if (doc.type === 'group') {
-            return getParts(doc.contents);
-        }
-    }
-}
-function attachCommentsHTML(node) {
-    if (!isNodeWithChildren(node) || !node.children.some(({ type }) => type === 'Comment'))
-        return;
-    const nodesToRemove = [];
-    for (let n = 0; n < node.children.length - 1; n++) {
-        if (!node.children[n])
-            continue;
-        if (node.children[n].type === 'Comment') {
-            let next = n + 1;
-            while (isEmptyTextNode(node.children[next])) {
-                nodesToRemove.push(next);
-                next++;
+                mindent = Math.min(mindent, indent);
             }
-            prettier.util.addLeadingComment(node.children[next], node.children[n]);
         }
-    }
-    nodesToRemove.reverse();
-    nodesToRemove.forEach((index) => {
-        node.children.splice(index, 1);
     });
-}
-function dedent$1(input) {
-    let minTabSize = Infinity;
-    let result = input;
-    result = result.replace(/\r\n/g, '\n');
-    let char = '';
-    for (const line of result.split('\n')) {
-        if (!line)
-            continue;
-        if (line[0] && /^[^\s]/.test(line[0])) {
-            minTabSize = 0;
-            break;
-        }
-        const match = line.match(/^(\s+)\S+/);
-        if (match) {
-            if (match[1] && !char)
-                char = match[1][0];
-            if (match[1].length < minTabSize)
-                minTabSize = match[1].length;
-        }
-    }
-    if (minTabSize > 0 && Number.isFinite(minTabSize)) {
-        result = result.replace(new RegExp(`^${new Array(minTabSize + 1).join(char)}`, 'gm'), '');
+    if (mindent !== null) {
+        (function () {
+            var m = mindent;
+            result = lines
+                .map(function (l) {
+                return l[0] === ' ' ? l.slice(m) : l;
+            })
+                .join('\n');
+        })();
     }
     return {
-        tabSize: minTabSize === Infinity ? 0 : minTabSize,
-        char,
-        result,
+        result: result
+            .trim()
+            .replace(/\\n/g, '\n'),
     };
 }
 function getMarkdownName(script) {
@@ -423,123 +253,27 @@ function getMarkdownName(script) {
     return new Set(['Markdown']);
 }
 function isTextNode(node) {
-    return node.type === 'Text';
-}
-function isDocCommand(doc) {
-    if (typeof doc === 'string')
-        return false;
-    if (Array.isArray(doc))
-        return false;
-    return true;
-}
-function isInsideQuotedAttribute(path) {
-    const stack = path.stack;
-    return stack.some((node) => node.type === 'Attribute' && !isLoneMustacheTag(node.value));
+    return node.type === 'text';
 }
 
 const { builders: { breakParent, dedent, fill, group, hardline, indent, join, line, literalline, softline }, utils: { removeLines, stripTrailingHardline }, } = _doc__default["default"];
-function printTopLevelParts(node, path, opts, print) {
-    let docs = [];
-    const normalize = (doc) => [stripTrailingHardline(doc), hardline];
-    if (node.module) {
-        const subDoc = normalize(path.call(print, 'module'));
-        docs.push(subDoc);
-    }
-    for (const section of parseSortOrder(opts.astroSortOrder)) {
-        switch (section) {
-            case 'markup': {
-                const subDoc = path.call(print, 'html');
-                if (!isEmptyDoc(subDoc))
-                    docs.push(normalize(subDoc));
-                break;
-            }
-            case 'styles': {
-                const subDoc = path.call(print, 'css');
-                if (!isEmptyDoc(subDoc))
-                    docs.push(normalize(subDoc));
-                break;
-            }
-        }
-    }
-    return join(softline, docs);
-}
-function printAttributeNodeValue(path, print, quotes, node) {
-    const valueDocs = path.map((childPath) => childPath.call(print), 'value');
-    if (!quotes || !formattableAttributes.includes(node.name)) {
-        return valueDocs;
-    }
-    else {
-        return indent(group(trim(valueDocs, isLine)));
-    }
-}
-function printJS(path, print, name, { forceSingleQuote, forceSingleLine }) {
-    path.getValue()[name].isJS = true;
-    path.getValue()[name].forceSingleQuote = forceSingleQuote;
-    path.getValue()[name].forceSingleLine = forceSingleLine;
-    return path.call(print, name);
-}
 function printComment(commentPath, options) {
     return commentPath;
 }
 function print(path, opts, print) {
-    var _a, _b;
     const node = path.getValue();
-    const isMarkdownSubDoc = opts.parentParser === 'markdown';
     if (!node) {
         return '';
     }
     if (typeof node === 'string') {
         return node;
     }
-    if (Array.isArray(node)) {
-        return path.map((childPath) => childPath.call(print));
-    }
-    if (isASTNode(node)) {
-        return printTopLevelParts(node, path, opts, print);
-    }
-    if (!isPreTagContent(path) && !isMarkdownSubDoc) {
-        attachCommentsHTML(node);
-    }
     switch (node.type) {
-        case 'Fragment': {
-            const text = getText(node, opts);
-            if (text.length === 0) {
-                return '';
-            }
-            if (!isNodeWithChildren(node) || node.children.every(isEmptyTextNode))
-                return '';
-            if (isMarkdownSubDoc) {
-                if (isEmptyTextNode(node.children[0]))
-                    node.children.shift();
-            }
-            const hasInlineComponent = node.children.filter((x) => x.type === 'InlineComponent').length > 0;
-            if (text.indexOf('{') === -1 && !hasInlineComponent) {
-                node.__isRawHTML = true;
-                node.content = text;
-                return path.call(print);
-            }
-            if (!isPreTagContent(path)) {
-                trimChildren(node.children);
-                const output = trim([path.map(print, 'children')], (n) => isLine(n) ||
-                    (typeof n === 'string' && n.trim() === '') ||
-                    n === breakParent);
-                if (output.every((doc) => isEmptyDoc(doc))) {
-                    return '';
-                }
-                return group([...output, hardline]);
-            }
-            else {
-                return group(path.map(print, 'children'));
-            }
+        case 'root': {
+            return [stripTrailingHardline(path.map(print, 'children')), hardline];
         }
-        case 'Text': {
+        case 'text': {
             const rawText = getUnencodedText(node);
-            if (isPreTagContent(path)) {
-                if (((_a = path.getParentNode()) === null || _a === void 0 ? void 0 : _a.type) === 'Attribute') {
-                    return replaceEndOfLineWith(rawText, literalline);
-                }
-                return rawText;
-            }
             if (isEmptyTextNode(node)) {
                 const hasWhiteSpace = rawText.trim().length < getUnencodedText(node).length;
                 const hasOneOrMoreNewlines = /\n/.test(getUnencodedText(node));
@@ -557,37 +291,20 @@ function print(path, opts, print) {
             }
             return fill(splitTextToDocs(node));
         }
-        case 'Element':
-        case 'InlineComponent':
-        case 'Slot': {
-            const isEmpty = (_b = node.children) === null || _b === void 0 ? void 0 : _b.every((child) => isEmptyTextNode(child));
-            const isSelfClosingTag = isEmpty && (node.type !== 'Element' || selfClosingTags.indexOf(node.name) !== -1);
-            const attributes = path.map(print, 'attributes');
-            if (isSelfClosingTag) {
-                return group(['<', node.name, indent(group(attributes)), line, `/>`]);
+        case 'component':
+        case 'fragment':
+        case 'element': {
+            let isEmpty;
+            if (!node.children) {
+                isEmpty = true;
             }
-            try {
-                if (node.name.toLowerCase() === '!doctype') {
-                    const attributesWithLowercaseHTML = attributes.map((attribute) => {
-                        if (typeof attribute === 'string')
-                            return attribute;
-                        if (isDocCommand(attribute))
-                            return attribute;
-                        attribute = attribute.map((attrValue) => {
-                            if (typeof attrValue !== 'string')
-                                return attrValue;
-                            if (attrValue.toLowerCase() === 'html') {
-                                attrValue = attrValue.toLowerCase();
-                            }
-                            return attrValue;
-                        });
-                        return attribute;
-                    });
-                    return group(['<', node.name.toUpperCase(), ...attributesWithLowercaseHTML, `>`]);
-                }
+            else {
+                isEmpty = node.children.every((child) => isEmptyTextNode(child));
             }
-            catch (e) {
-                console.warn(`error ${e} in the doctype printing`);
+            const isSelfClosingTag = isEmpty && (node.type !== 'element' || selfClosingTags.indexOf(node.name) !== -1);
+            const attributes = node.attributes ? path.map(print, 'attributes') : [];
+            if (isSelfClosingTag) {
+                return group(['<', node.name, indent(group(attributes)), line, `/>`]);
             }
             if (node.children) {
                 const children = node.children;
@@ -598,7 +315,6 @@ function print(path, opts, print) {
                 let hugStart = shouldHugStart(node, opts);
                 let hugEnd = shouldHugEnd(node, opts);
                 let body;
-                const isMarkdownComponent = node.type === 'InlineComponent' && opts.__astro && opts.__astro.markdownName && opts.__astro.markdownName.has(node.name) && isNodeWithChildren(node);
                 if (isEmpty) {
                     body =
                         isInlineElement(path, opts, node) && node.children.length && isTextNodeStartingWithWhitespace(node.children[0]) && !isPreTagContent(path)
@@ -606,15 +322,8 @@ function print(path, opts, print) {
                             :
                                 () => softline;
                 }
-                else if (isMarkdownComponent) {
-                    const text = node.children.map(getUnencodedText).join('').trim();
-                    node.children = [{ start: firstChild.start, end: lastChild.end - 2, type: 'Text', data: text, raw: text, __isRawMarkdown: true }];
-                    body = () => path.map(print, 'children');
-                    hugStart = false;
-                    hugEnd = false;
-                }
                 else if (isPreTagContent(path)) {
-                    body = () => printRaw(node, opts.originalText);
+                    body = () => printRaw(node);
                 }
                 else if (isInlineElement(path, opts, node) && !isPreTagContent(path)) {
                     body = () => path.map(print, 'children');
@@ -632,10 +341,6 @@ function print(path, opts, print) {
                     noHugSeparatorStart = '';
                     noHugSeparatorEnd = '';
                 }
-                else if (isMarkdownComponent) {
-                    noHugSeparatorStart = softline;
-                    noHugSeparatorEnd = softline;
-                }
                 else {
                     let didSetEndSeparator = false;
                     if (!hugStart && firstChild && isTextNode(firstChild)) {
@@ -651,7 +356,7 @@ function print(path, opts, print) {
                     }
                     if (!hugEnd && lastChild && isTextNode(lastChild)) {
                         if (isInlineElement(path, opts, node) && !didSetEndSeparator) {
-                            noHugSeparatorEnd = line;
+                            noHugSeparatorEnd = softline;
                         }
                         trimTextNodeRight(lastChild);
                     }
@@ -667,47 +372,35 @@ function print(path, opts, print) {
                 }
                 return group([...openingTag, '>', indent([noHugSeparatorStart, body()]), noHugSeparatorEnd, `</${node.name}>`]);
             }
+            return '';
+        }
+        case 'attribute': {
+            const name = node.name.trim();
+            const quote = opts.singleQuote ? "'" : '"';
+            switch (node.kind) {
+                case 'empty':
+                    return [line, name];
+                case 'expression':
+                    return '';
+                case 'quoted':
+                    return [line, name, '=', quote, node.value, quote];
+                case 'shorthand':
+                    return [line, '{', name, '}'];
+                case 'spread':
+                    return [line, '{...', name, '}'];
+                case 'template-literal':
+                    return [line, name, '=', '`', node.value, '`'];
+            }
+            return '';
         }
-        case 'AttributeShorthand': {
-            return node.expression.name;
+        case 'directive': {
+            return [line, node.name];
         }
-        case 'Attribute': {
-            if (isOrCanBeConvertedToShorthand(node, opts)) {
-                return [line, '{', node.name, '}'];
-            }
-            else {
-                if (node.value === true) {
-                    return [line, node.name];
-                }
-                const quotes = !isLoneMustacheTag(node.value);
-                const attrNodeValue = printAttributeNodeValue(path, print, quotes, node);
-                if (quotes) {
-                    return [line, node.name, '=', '"', attrNodeValue, '"'];
-                }
-                else {
-                    return [line, node.name, '=', attrNodeValue];
-                }
-            }
+        case 'doctype': {
+            return ['<!DOCTYPE html>', hardline];
         }
-        case 'Expression':
-            return [];
-        case 'MustacheTag':
-            return [
-                '{',
-                printJS(path, print, 'expression', {
-                    forceSingleLine: isInsideQuotedAttribute(path),
-                    forceSingleQuote: opts.jsxSingleQuote,
-                }),
-                '}',
-            ];
-        case 'Comment':
+        case 'comment':
             return ['<!--', getUnencodedText(node), '-->'];
-        case 'CodeSpan':
-            return getUnencodedText(node);
-        case 'CodeFence': {
-            console.debug(node);
-            return [node.metadata, hardline, node.data, hardline, '```', hardline];
-        }
         default: {
             throw new Error(`Unhandled node type "${node.type}"!`);
         }
@@ -732,66 +425,62 @@ function splitTextToDocs(node) {
     return docs;
 }
 function expressionParser(text, parsers, opts) {
-    const ast = parsers.babel(text, parsers, opts);
+    const ast = parsers.babel(text, opts);
     return { ...ast, program: ast.program.body[0].expression };
 }
+let markdownComponentName = new Set();
 function embed(path, print, textToDoc, opts) {
     if (!opts.__astro)
         opts.__astro = {};
     const node = path.getValue();
     if (!node)
         return null;
-    if (node.__isRawMarkdown) {
-        const docs = textToDoc(getUnencodedText(node), { ...opts, parser: 'markdown' });
-        return stripTrailingHardline(docs);
-    }
-    if (node.type === 'Script' && !opts.__astro.markdownName) {
-        opts.__astro.markdownName = getMarkdownName(node.content);
-    }
-    if (node.isJS) {
-        try {
-            const embeddedopts = {
-                parser: expressionParser,
-            };
-            if (node.forceSingleQuote) {
-                embeddedopts.singleQuote = true;
-            }
-            const docs = textToDoc(forceIntoExpression(getText(node, opts)), embeddedopts);
-            return node.forceSingleLine ? removeLines(docs) : docs;
-        }
-        catch (e) {
-            return getText(node, opts);
-        }
-    }
-    if (node.type === 'Script' && node.context === 'setup') {
-        return group(['---', hardline, textToDoc(node.content, { ...opts, parser: 'typescript' }), '---', hardline]);
-    }
-    if (isTextNode(node)) {
-        const parent = path.getParentNode();
-        if (parent && parent.type === 'Element' && parent.name === 'script') {
-            const formatttedScript = textToDoc(node.data, { ...opts, parser: 'typescript' });
-            if (typeof formatttedScript === 'string')
-                return formatttedScript;
-            if (isDocCommand(formatttedScript))
-                return formatttedScript;
-            return group(formatttedScript[0]);
-        }
-    }
-    if (node.type === 'Style' || (node.type === 'Element' && node.name === 'style')) {
-        let styleTagContent = '';
-        if (node.type === 'Style') {
-            styleTagContent = node.content.styles;
-        }
-        else if (node.children) {
-            const children = node.children[0];
-            styleTagContent = getUnencodedText(children);
+    if (node.type === 'expression') {
+        const textContent = getText(node, opts);
+        let content;
+        if (node.children.length === 1) {
+            content = textContent;
         }
+        else {
+            content = textToDoc(textContent, { ...opts, parser: 'babel-ts', semi: false });
+            content = stripTrailingHardline(content);
+        }
+        return [
+            '{',
+            content,
+            '}',
+        ];
+    }
+    if (node.type === 'attribute' && node.kind === 'expression') {
+        const value = node.value.trim();
+        const name = node.name.trim();
+        let attrNodeValue = textToDoc(forceIntoExpression(value), { ...opts, parser: expressionParser, semi: false });
+        attrNodeValue = stripTrailingHardline(attrNodeValue);
+        if (name === value && opts.astroAllowShorthand) {
+            return [line, '{', attrNodeValue, '}'];
+        }
+        return [line, name, '=', '{', attrNodeValue, '}'];
+    }
+    if (node.type === 'frontmatter') {
+        markdownComponentName = getMarkdownName(node.value);
+        return [group(['---', hardline, textToDoc(node.value, { ...opts, parser: 'typescript' }), '---', hardline]), hardline];
+    }
+    if (node.type === 'element' && node.name === 'script') {
+        const scriptContent = node.children[0].value;
+        let formatttedScript = textToDoc(scriptContent, { ...opts, parser: 'typescript' });
+        formatttedScript = stripTrailingHardline(formatttedScript);
+        const attributes = node.attributes ? path.map(print, 'attributes') : [];
+        const openingTag = group(['<script', indent(group(attributes)), softline, '>']);
+        return [openingTag, indent([hardline, formatttedScript]), hardline, '</script>'];
+    }
+    if (node.type === 'element' && node.name === 'style') {
+        let styleTagContent = node.children[0].value.trim();
         const supportedStyleLangValues = ['css', 'scss', 'sass'];
         let parserLang = 'css';
-        if ('attributes' in node) {
+        if (node.attributes) {
             const langAttribute = node.attributes.filter((x) => x.name === 'lang');
             if (langAttribute.length) {
-                const styleLang = langAttribute[0].value[0].raw.toLowerCase();
+                const styleLang = langAttribute[0].value.toLowerCase();
                 if (supportedStyleLangValues.includes(styleLang))
                     parserLang = styleLang;
             }
@@ -800,13 +489,11 @@ function embed(path, print, textToDoc, opts) {
             case 'css':
             case 'scss': {
                 let formattedStyles = textToDoc(styleTagContent, { ...opts, parser: parserLang });
-                if (typeof formattedStyles === 'string')
-                    return formattedStyles;
-                if (isDocCommand(formattedStyles))
-                    return formattedStyles;
-                formattedStyles = formattedStyles[0];
-                const attributes = path.map(print, 'attributes');
-                const openingTag = group(['<style', indent(group(attributes)), softline, '>']);
+                formattedStyles = stripTrailingHardline(formattedStyles);
+                const attributes = node.attributes ? path.map(print, 'attributes') : [];
+                const directives = node.directives ? path.map(print, 'directives') : [];
+                const attrAndDirectives = directives.concat(attributes);
+                const openingTag = group(['<style', indent(group(attrAndDirectives)), softline, '>']);
                 return [openingTag, indent([hardline, formattedStyles]), hardline, '</style>'];
             }
             case 'sass': {
@@ -816,17 +503,25 @@ function embed(path, print, textToDoc, opts) {
                     insertSpaces: !opts.useTabs,
                     lineEnding,
                 };
-                const { result: raw } = dedent$1(styleTagContent);
+                const { result: raw } = manualDedent(styleTagContent);
                 let formattedSassIndented = sassFormatter.SassFormatter.Format(raw, sassOptions).trim();
                 const formattedSass = join(hardline, formattedSassIndented.split('\n'));
-                const attributes = path.map(print, 'attributes');
+                const attributes = node.attributes ? path.map(print, 'attributes') : [];
                 const openingTag = group(['<style', indent(group(attributes)), softline, '>']);
                 return [openingTag, indent(group([hardline, formattedSass])), hardline, '</style>'];
             }
         }
     }
-    if (node.__isRawHTML) {
-        return textToDoc(node.content, { ...opts, parser: 'html' });
+    if (node.type === 'component' && markdownComponentName.has(node.name)) {
+        let content = printRaw(node);
+        content = content.replace(/\r\n/g, '\n');
+        const contentArr = content.split('\n').map((s) => s.trimStart());
+        content = contentArr.join('\n');
+        let formatttedMarkdown = textToDoc(content, { ...opts, parser: 'markdown' });
+        formatttedMarkdown = stripTrailingHardline(formatttedMarkdown);
+        const attributes = path.map(print, 'attributes');
+        const openingTag = group([`<${node.name}`, indent(group(attributes)), softline, '>']);
+        return [openingTag, indent(group([hardline, formatttedMarkdown])), hardline, `</${node.name}>`];
     }
     return null;
 }
@@ -844,6 +539,33 @@ const printer = {
     hasPrettierIgnore,
 };
 
+const options = {
+    astroSortOrder: {
+        since: '0.0.1',
+        category: 'Astro',
+        type: 'choice',
+        default: 'markup | styles',
+        description: 'Sort order for markup, scripts, and styles',
+        choices: [
+            {
+                value: 'markup | styles',
+                description: 'markup | styles',
+            },
+            {
+                value: 'styles | markup',
+                description: 'styles | markup',
+            },
+        ],
+    },
+    astroAllowShorthand: {
+        since: '0.0.10',
+        category: 'Astro',
+        type: 'boolean',
+        default: true,
+        description: 'Enable/disable attribute shorthand if attribute name and expression are the same',
+    },
+};
+
 const languages = [
     {
         name: 'astro',