prettier-plugin-astro 0.14.1 → 1.0.0-beta.1

package/dist/index.js

@@ -1,9 +1,6 @@
-import { parse } from '@astrojs/compiler/sync';
-import * as prettierPluginBabel from 'prettier/plugins/babel';
-import 'prettier';
-import { serialize } from '@astrojs/compiler/utils';
-import _doc from 'prettier/doc';
-import { Buffer } from 'node:buffer';
+import { parse as parse$1 } from '@astrojs/compiler-rs';
+import { doc } from 'prettier';
+import { printers as printers$1 } from 'prettier/plugins/estree';
 import { SassFormatter } from 'sass-formatter';
 
 const options = {
@@ -19,9 +16,114 @@ const options = {
         default: false,
         description: 'Skips the formatting of the frontmatter.',
     },
+    astroCompressHTML: {
+        category: 'Astro',
+        type: 'choice',
+        default: 'jsx',
+        description: "Mirror of Astro's compressHTML config. Tells the formatter which whitespace the compiler will collapse.",
+        choices: [
+            {
+                value: 'jsx',
+                description: "Astro's default since 7.0.0. Whitespace runs containing a newline are dropped; same-line spaces are content.",
+            },
+            {
+                value: 'html',
+                description: 'Browser HTML whitespace rules. Equivalent to compressHTML: true.',
+            },
+            { value: 'none', description: 'No collapsing. Equivalent to compressHTML: false.' },
+            { value: true, redirect: 'html' },
+            { value: false, redirect: 'none' },
+        ],
+    },
 };
 
-const selfClosingTags = [
+const synthetic = Symbol.for('prettier-plugin-astro.synthetic');
+const ownChildren = Symbol.for('prettier-plugin-astro.ownChildren');
+const astroVisitorKeys = {
+    AstroRoot: ['frontmatter', 'template'],
+    AstroFrontmatter: ['program'],
+    AstroScript: ['program'],
+    AstroDoctype: [],
+    AstroComment: [],
+};
+const isNode = (value) => typeof value === 'object' && value !== null && typeof value.type === 'string';
+function tagNameOf(node) {
+    if (node.type !== 'JSXElement')
+        return null;
+    const name = node.openingElement?.name;
+    return name?.type === 'JSXIdentifier' ? name.name : null;
+}
+const isComponentName = (name) => name === null || /^[A-Z]/.test(name) || name.includes('.');
+function attributesOf(node) {
+    const opening = node.openingElement;
+    return opening?.attributes ?? [];
+}
+function attributeNamed(node, name) {
+    return attributesOf(node).find((attribute) => attribute.type === 'JSXAttribute' && attribute.name.name === name);
+}
+function attributeStringValue(node, name) {
+    const value = attributeNamed(node, name)?.value;
+    return value?.type === 'Literal' && typeof value.value === 'string' ? value.value : null;
+}
+const hasAttribute = (node, name) => attributeNamed(node, name) !== undefined;
+const hasSetDirective = (node) => hasAttribute(node, 'set:html') || hasAttribute(node, 'set:text');
+function childrenOf(node) {
+    if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+        return node.astroChildren ?? node.children;
+    }
+    return null;
+}
+function takeOverChildren(node) {
+    const children = node.children;
+    if (children.length === 0)
+        return;
+    node.astroChildren = children;
+    node.children = [
+        {
+            type: 'JSXExpressionContainer',
+            start: node.start,
+            end: node.end,
+            [ownChildren]: true,
+            expression: {
+                type: 'TemplateLiteral',
+                start: node.start,
+                end: node.end,
+                quasis: [],
+                expressions: [],
+            },
+        },
+    ];
+}
+function walk(node, visit) {
+    if (Array.isArray(node)) {
+        for (const item of node)
+            walk(item, visit);
+        return;
+    }
+    if (!isNode(node))
+        return;
+    visit(node);
+    for (const key of Object.keys(node)) {
+        if (key !== 'type')
+            walk(node[key], visit);
+    }
+}
+
+const rawTextElements = new Set([
+    'pre',
+    'listing',
+    'iframe',
+    'noembed',
+    'noframes',
+    'math',
+    'plaintext',
+    'script',
+    'style',
+    'textarea',
+    'title',
+    'xmp',
+]);
+const voidElements = new Set([
     'area',
     'base',
     'basefont',
@@ -42,267 +144,692 @@ const selfClosingTags = [
     'meta',
     'nextid',
     'param',
-    'slot',
     'source',
     'track',
     'wbr',
-];
-const blockElements = [
-    'address',
-    'article',
-    'aside',
-    'blockquote',
-    'details',
-    'dialog',
-    'dd',
-    'div',
-    'dl',
-    'dt',
-    'fieldset',
-    'figcaption',
-    'figure',
-    'footer',
-    'form',
-    'h1',
-    'h2',
-    'h3',
-    'h4',
-    'h5',
-    'h6',
-    'header',
-    'hgroup',
-    'hr',
-    'li',
-    'main',
-    'nav',
-    'ol',
-    'p',
-    'pre',
-    'section',
-    'table',
-    'ul',
-    'title',
-    'html',
-];
-const formattableAttributes = [];
-
-const openingBracketReplace = '_Pé';
-const closingBracketReplace = 'èP_';
-const atSignReplace = 'ΩP_';
-const dotReplace = 'ωP_';
-const interrogationReplace = 'ΔP_';
-function isInlineElement(path, opts, node) {
-    return node && isTagLikeNode(node) && !isBlockElement(node, opts) && !isPreTagContent(path);
-}
-function isBlockElement(node, opts) {
-    return (node &&
-        node.type === 'element' &&
-        opts.htmlWhitespaceSensitivity !== 'strict' &&
-        (opts.htmlWhitespaceSensitivity === 'ignore' || blockElements.includes(node.name)));
-}
-function isIgnoreDirective(node) {
-    return node.type === 'comment' && node.value.trim() === 'prettier-ignore';
-}
-function printRaw(node, stripLeadingAndTrailingNewline = false) {
-    if (!isNodeWithChildren(node)) {
-        return '';
-    }
-    if (node.children.length === 0) {
-        return '';
-    }
-    let raw = node.children.reduce((prev, curr) => prev + serialize(curr), '');
-    if (!stripLeadingAndTrailingNewline) {
-        return raw;
-    }
-    if (startsWithLinebreak(raw)) {
-        raw = raw.substring(raw.indexOf('\n') + 1);
-    }
-    if (endsWithLinebreak(raw)) {
-        raw = raw.substring(0, raw.lastIndexOf('\n'));
-        if (raw.charAt(raw.length - 1) === '\r') {
-            raw = raw.substring(0, raw.length - 1);
-        }
-    }
-    return raw;
-}
-function isNodeWithChildren(node) {
-    return node && 'children' in node && Array.isArray(node.children);
-}
-const isEmptyTextNode = (node) => {
-    return !!node && node.type === 'text' && getUnencodedText(node).trim() === '';
+]);
+const cssDisplay = {
+    area: 'none',
+    base: 'none',
+    basefont: 'none',
+    datalist: 'none',
+    head: 'none',
+    link: 'none',
+    meta: 'none',
+    noembed: 'none',
+    noframes: 'none',
+    param: 'block',
+    rp: 'none',
+    script: 'block',
+    style: 'none',
+    template: 'inline',
+    title: 'none',
+    html: 'block',
+    body: 'block',
+    address: 'block',
+    blockquote: 'block',
+    center: 'block',
+    dialog: 'block',
+    div: 'block',
+    figure: 'block',
+    figcaption: 'block',
+    footer: 'block',
+    form: 'block',
+    header: 'block',
+    hr: 'block',
+    legend: 'block',
+    listing: 'block',
+    main: 'block',
+    p: 'block',
+    plaintext: 'block',
+    pre: 'block',
+    search: 'block',
+    xmp: 'block',
+    slot: 'contents',
+    ruby: 'ruby',
+    rt: 'ruby-text',
+    article: 'block',
+    aside: 'block',
+    h1: 'block',
+    h2: 'block',
+    h3: 'block',
+    h4: 'block',
+    h5: 'block',
+    h6: 'block',
+    hgroup: 'block',
+    nav: 'block',
+    section: 'block',
+    dir: 'block',
+    dd: 'block',
+    dl: 'block',
+    dt: 'block',
+    menu: 'block',
+    ol: 'block',
+    ul: 'block',
+    li: 'list-item',
+    table: 'table',
+    caption: 'table-caption',
+    colgroup: 'table-column-group',
+    col: 'table-column',
+    thead: 'table-header-group',
+    tbody: 'table-row-group',
+    tfoot: 'table-footer-group',
+    tr: 'table-row',
+    td: 'table-cell',
+    th: 'table-cell',
+    input: 'inline-block',
+    button: 'inline-block',
+    fieldset: 'block',
+    details: 'block',
+    summary: 'block',
+    marquee: 'inline-block',
+    source: 'block',
+    track: 'block',
+    meter: 'inline-block',
+    progress: 'inline-block',
+    object: 'inline-block',
+    video: 'inline-block',
+    audio: 'inline-block',
+    select: 'inline-block',
+    option: 'block',
+    optgroup: 'block',
 };
-function getUnencodedText(node) {
-    return node.value;
-}
-function isTextNodeStartingWithLinebreak(node, nrLines = 1) {
-    return startsWithLinebreak(getUnencodedText(node), nrLines);
+const inlineLevel = new Set(['inline', 'inline-block', 'ruby', 'ruby-text', 'contents']);
+function displayOfTag(tag) {
+    return cssDisplay[tag] ?? 'inline';
 }
-function startsWithLinebreak(text, nrLines = 1) {
-    return new RegExp(`^([\\t\\f\\r ]*\\n){${nrLines}}`).test(text);
+function isInlineDisplay(display) {
+    return inlineLevel.has(display);
 }
-function endsWithLinebreak(text, nrLines = 1) {
-    return new RegExp(`(\\n[\\t\\f\\r ]*){${nrLines}}$`).test(text);
+
+function manualDedent(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 = /^(\s+)\S+/.exec(line);
+        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'), '');
+    }
+    return {
+        tabSize: minTabSize === Infinity ? 0 : minTabSize,
+        char,
+        result,
+    };
 }
-function isTextNodeStartingWithWhitespace(node) {
-    return isTextNode(node) && /^\s/.test(getUnencodedText(node));
+function printClassNames(value) {
+    const lines = value.trim().split(/[\r\n]+/);
+    const formattedLines = lines.map((line) => {
+        const spaces = /^\s+/.exec(line);
+        return (spaces ? spaces[0] : '') + line.trim().split(/\s+/).join(' ');
+    });
+    return formattedLines.join('\n');
 }
-function endsWithWhitespace(text) {
-    return /\s$/.test(text);
+
+const leadingWhitespace$1 = /^[\t\n\f\r ]+/;
+const trailingWhitespace$1 = /[\t\n\f\r ]+$/;
+const hasNewline = (run) => /[\n\r]/.test(run);
+const isText = (node) => node?.type === 'JSXText';
+const rawTextOf = (node) => node.raw ?? '';
+const isWhitespaceOnly = (node) => isText(node) && rawTextOf(node).trim().length === 0;
+function opensRawSubtree(node) {
+    if (node.type !== 'JSXElement')
+        return false;
+    if (hasAttribute(node, 'is:raw'))
+        return true;
+    const tag = tagNameOf(node);
+    return tag !== null && !isComponentName(tag) && rawTextElements.has(tag);
 }
-function isTextNodeEndingWithWhitespace(node) {
-    return isTextNode(node) && endsWithWhitespace(getUnencodedText(node));
+const isExtractedStyle = (node) => node !== null && tagNameOf(node) === 'style' && !hasAttribute(node, 'is:inline');
+function displayOf(node) {
+    if (node.type !== 'JSXElement')
+        return 'inline';
+    const tag = tagNameOf(node);
+    if (tag === null || isComponentName(tag) || tag.includes('-'))
+        return 'inline';
+    return displayOfTag(tag);
 }
-function hasSetDirectives(node) {
-    const attributes = Array.from(node.attributes, (attr) => attr.name);
-    return attributes.some((attr) => ['set:html', 'set:text'].includes(attr));
+const isBlankRun = (run) => /[\n\r][^\S\n\r]*[\n\r]/.test(run);
+function sidesFor(boundary) {
+    if (boundary.edge)
+        return [null];
+    const sides = [];
+    if (boundary.prev === null)
+        sides.push(null);
+    else if (boundary.prev.type !== 'JSXText')
+        sides.push(boundary.prev);
+    if (boundary.next === null)
+        sides.push(null);
+    else if (boundary.next.type !== 'JSXText')
+        sides.push(boundary.next);
+    return sides.length > 0 ? sides : null;
 }
-function shouldHugStart(node, opts) {
-    if (isBlockElement(node, opts)) {
+function blankContentIsFree(container, isRoot, settings) {
+    const tag = container.type === 'JSXElement' ? tagNameOf(container) : null;
+    if (tag === 'slot')
         return false;
-    }
-    if (!isNodeWithChildren(node)) {
+    if (tag !== null && !isComponentName(tag) && tag.includes('-'))
         return false;
+    const boundary = {
+        container,
+        context: { ...settings, isRoot, inRaw: false },
+        prev: null,
+        next: null,
+        sides: [null],
+        atStart: true,
+        atEnd: true,
+        loneChild: true,
+    };
+    return isFree(boundary) || mayAlterRenderedWhitespace(boundary);
+}
+function separatorFor(run, boundary, settings) {
+    const sides = sidesFor(boundary);
+    const internal = {
+        container: boundary.container,
+        context: { ...settings, isRoot: boundary.isRoot, inRaw: false },
+        prev: boundary.prev,
+        next: boundary.next,
+        sides: sides ?? [],
+        atStart: boundary.prev === null,
+        atEnd: boundary.next === null,
+        loneChild: boundary.loneChild,
+    };
+    if (isSlotFallback(internal))
+        return run === '' ? 'none' : 'space';
+    const free = isFree(internal) || (sides !== null && mayAlterRenderedWhitespace(internal));
+    if (boundary.edge) {
+        if (free)
+            return 'soft';
+        return run === '' ? 'none' : 'space';
     }
-    const children = node.children;
-    if (children.length === 0) {
-        return true;
+    if (isBlankRun(run))
+        return 'blank';
+    if (hasNewline(run))
+        return 'break';
+    if (free)
+        return 'soft';
+    return run === '' ? 'none' : 'space';
+}
+function normalizeWhitespace(template, options) {
+    visit(template, { ...options, isRoot: true, inRaw: false });
+}
+function visit(container, context) {
+    const children = childrenOf(container);
+    if (children === null)
+        return;
+    if (!context.inRaw)
+        collapseRuns(container, children, context);
+    for (const child of children) {
+        visit(child, {
+            ...context,
+            isRoot: false,
+            inRaw: context.inRaw || opensRawSubtree(child),
+        });
     }
-    const firstChild = children[0];
-    return !isTextNodeStartingWithWhitespace(firstChild);
 }
-function shouldHugEnd(node, opts) {
-    if (isBlockElement(node, opts)) {
-        return false;
+function collapseRuns(container, children, context) {
+    const dropped = new Set();
+    for (const [index, child] of children.entries()) {
+        if (!isText(child))
+            continue;
+        const prev = children[index - 1] ?? null;
+        const next = children[index + 1] ?? null;
+        if (isWhitespaceOnly(child)) {
+            const decision = decide(rawTextOf(child), {
+                container,
+                context,
+                prev,
+                next,
+                sides: [prev, next],
+                atStart: prev === null,
+                atEnd: next === null,
+                loneChild: children.length === 1,
+            });
+            const text = resolve(rawTextOf(child), decision);
+            if (text === '')
+                dropped.add(child);
+            else
+                setText(child, text);
+            continue;
+        }
+        const raw = rawTextOf(child);
+        const lead = leadingWhitespace$1.exec(raw)?.[0] ?? '';
+        const trail = trailingWhitespace$1.exec(raw)?.[0] ?? '';
+        const body = raw.slice(lead.length, raw.length - trail.length);
+        const leadDecision = decide(lead, {
+            container,
+            context,
+            prev,
+            next: child,
+            sides: [prev],
+            atStart: prev === null,
+            atEnd: false,
+            loneChild: false,
+        });
+        const trailDecision = decide(trail, {
+            container,
+            context,
+            prev: child,
+            next,
+            sides: [next],
+            atStart: false,
+            atEnd: next === null,
+            loneChild: false,
+        });
+        setText(child, resolve(lead, leadDecision) + body + resolve(trail, trailDecision));
     }
-    if (!isNodeWithChildren(node)) {
-        return false;
+    if (dropped.size > 0) {
+        const kept = children.filter((child) => !dropped.has(child));
+        children.length = 0;
+        children.push(...kept);
     }
-    const children = node.children;
-    if (children.length === 0) {
+}
+function resolve(run, decision) {
+    if (decision === 'drop')
+        return hasNewline(run) ? run : '';
+    if (decision === 'space')
+        return ' ';
+    return run;
+}
+function setText(node, text) {
+    node.raw = text;
+    node.value = text;
+}
+function decide(run, boundary) {
+    if (run === '')
+        return 'keep';
+    const { mode } = boundary.context;
+    if (isSlotFallback(boundary))
+        return 'space';
+    if (isFree(boundary))
+        return 'drop';
+    if (mayAlterRenderedWhitespace(boundary))
+        return 'drop';
+    if (mode === 'jsx')
+        return hasNewline(run) ? 'keep' : 'space';
+    return boundary.atStart || boundary.atEnd ? 'space' : 'keep';
+}
+function isFree(boundary) {
+    const { container, context, atStart, atEnd, loneChild } = boundary;
+    const { mode } = context;
+    if (context.isRoot && (atStart || atEnd))
         return true;
-    }
-    const lastChild = children[children.length - 1];
-    if (isExpressionNode(lastChild))
+    if (container.type === 'JSXElement' && hasSetDirective(container))
         return true;
-    if (isTagLikeNode(lastChild))
+    if (isExtractedStyle(boundary.prev) || isExtractedStyle(boundary.next))
         return true;
-    return !isTextNodeEndingWithWhitespace(lastChild);
-}
-function canOmitSoftlineBeforeClosingTag(path, opts) {
-    return isLastChildWithinParentBlockElement(path, opts);
-}
-function getChildren(node) {
-    return isNodeWithChildren(node) ? node.children : [];
+    const tag = container.type === 'JSXElement' ? tagNameOf(container) : null;
+    if (loneChild && tag !== null && isComponentName(tag))
+        return true;
+    if (mode === 'html') {
+        if (loneChild)
+            return true;
+        if (tag === 'head')
+            return true;
+    }
+    return false;
 }
-function isLastChildWithinParentBlockElement(path, opts) {
-    const parent = path.getParentNode();
-    if (!parent || !isBlockElement(parent, opts)) {
+function mayAlterRenderedWhitespace(boundary) {
+    const { sensitivity } = boundary.context;
+    if (sensitivity === 'ignore')
+        return true;
+    if (sensitivity === 'strict')
         return false;
-    }
-    const children = getChildren(parent);
-    const lastChild = children[children.length - 1];
-    return lastChild === path.getNode();
+    return boundary.sides.every((side) => !isInlineDisplay(displayOf(side ?? boundary.container)));
 }
-function trimTextNodeLeft(node) {
-    node.value = node.value && node.value.trimStart();
+function isSlotFallback(boundary) {
+    return (boundary.container.type === 'JSXElement' &&
+        tagNameOf(boundary.container) === 'slot' &&
+        boundary.loneChild);
 }
-function trimTextNodeRight(node) {
-    node.value = node.value && node.value.trimEnd();
+
+function parse(source, options) {
+    const { ast, diagnostics } = parse$1(source);
+    const failure = diagnostics.find((diagnostic) => diagnostic.severity === 'error');
+    if (failure)
+        throw syntaxError(failure);
+    stripParentheses(ast);
+    repairSpans(ast);
+    markAttributes(ast, source);
+    applyPrettierIgnore(ast);
+    const body = ast.body;
+    const template = templateFragment(ast, body);
+    const settings = {
+        mode: options.astroCompressHTML,
+        sensitivity: options.htmlWhitespaceSensitivity,
+    };
+    if (settings.mode === 'jsx')
+        normalizeWhitespace(template.node, settings);
+    else
+        resolveBlankContainers(template.node, settings);
+    normalizeTagPairs(body, source);
+    if (settings.mode !== 'jsx')
+        claimChildren(template.node);
+    ast.template = template;
+    delete ast.body;
+    ast.comments = printableComments(ast);
+    return ast;
 }
-function printClassNames(value) {
-    const lines = value.trim().split(/[\r\n]+/);
-    const formattedLines = lines.map((line) => {
-        const spaces = line.match(/^\s+/);
-        return (spaces ? spaces[0] : '') + line.trim().split(/\s+/).join(' ');
+function syntaxError(diagnostic) {
+    const label = diagnostic.labels[0];
+    const line = label?.line ?? 1;
+    const column = (label?.column ?? 0) + 1;
+    const error = new SyntaxError(`${diagnostic.text} (${line}:${column})`);
+    error.loc = { start: { line, column } };
+    return error;
+}
+function stripParentheses(root) {
+    walk(root, (node) => {
+        for (const key of Object.keys(node)) {
+            const value = node[key];
+            if (Array.isArray(value)) {
+                for (const [index, item] of value.entries()) {
+                    value[index] = unwrapParens(item);
+                }
+            }
+            else if (isNode(value)) {
+                node[key] = unwrapParens(value);
+            }
+        }
     });
-    return formattedLines.join('\n');
 }
-function manualDedent(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;
+function unwrapParens(node) {
+    let current = node;
+    while (isNode(current)) {
+        if (current.type === 'ParenthesizedExpression')
+            current = current.expression;
+        else if (current.type === 'TSParenthesizedType')
+            current = current.typeAnnotation;
+        else
             break;
+    }
+    return current;
+}
+function repairSpans(root) {
+    walk(root, (node) => {
+        if (node.type !== 'JSXElement')
+            return;
+        const script = node.children.find((child) => child.type === 'AstroScript');
+        if (!script)
+            return;
+        script.start = node.openingElement.end;
+        script.end = node.closingElement?.start ?? node.end;
+    });
+}
+function markAttributes(root, source) {
+    walk(root, (node) => {
+        if (node.type !== 'JSXAttribute')
+            return;
+        const value = node.value;
+        if (!value)
+            return;
+        if (value.type === 'Literal' && typeof value.value === 'string') {
+            const name = node.name.name;
+            const text = name === 'class' ? printClassNames(value.value) : value.value;
+            if (value.raw === null || text !== value.value) {
+                value.value = text;
+                value.raw = `"${text.replaceAll('"', '&quot;')}"`;
+            }
+            return;
         }
-        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 (value.type !== 'JSXExpressionContainer')
+            return;
+        if (source[node.start] === '{')
+            node.astroShorthand = true;
+        if (source[value.start] === '`')
+            node.astroBacktick = true;
+    });
+}
+function applyPrettierIgnore(root) {
+    walk(root, (node) => {
+        const children = node.type === 'AstroRoot' ? node.body : childrenOf(node);
+        if (children === null)
+            return;
+        for (const [index, child] of children.entries()) {
+            if (child.type !== 'AstroComment')
+                continue;
+            if (String(child.value).trim() !== 'prettier-ignore')
+                continue;
+            const target = children.slice(index + 1).find((sibling) => sibling.type !== 'JSXText');
+            if (target)
+                target.astroIgnored = true;
         }
-    }
-    if (minTabSize > 0 && Number.isFinite(minTabSize)) {
-        result = result.replace(new RegExp(`^${new Array(minTabSize + 1).join(char)}`, 'gm'), '');
-    }
+    });
+}
+function templateFragment(root, body) {
+    const start = body[0]?.start ?? root.end;
+    const end = body.at(-1)?.end ?? root.end;
     return {
-        tabSize: minTabSize === Infinity ? 0 : minTabSize,
-        char,
-        result,
+        type: 'JsExpressionRoot',
+        start,
+        end,
+        node: {
+            type: 'JSXFragment',
+            start,
+            end,
+            astroRoot: true,
+            openingFragment: { type: 'JSXOpeningFragment', start, end: start, [synthetic]: true },
+            children: body,
+            closingFragment: { type: 'JSXClosingFragment', start: end, end, [synthetic]: true },
+        },
     };
 }
-function isTextNode(node) {
-    return node.type === 'text';
-}
-function isExpressionNode(node) {
-    return node.type === 'expression';
-}
-function isTagLikeNode(node) {
-    return (node.type === 'element' ||
-        node.type === 'component' ||
-        node.type === 'custom-element' ||
-        node.type === 'fragment');
-}
-function getSiblings(path) {
-    const parent = path.getParentNode();
-    if (!parent)
-        return [];
-    return getChildren(parent);
-}
-function getNextNode(path) {
-    const node = path.getNode();
-    if (node) {
-        const siblings = getSiblings(path);
-        if (node.position?.start === siblings[siblings.length - 1].position?.start)
-            return null;
-        for (let i = 0; i < siblings.length; i++) {
-            const sibling = siblings[i];
-            if (sibling.position?.start === node.position?.start && i !== siblings.length - 1) {
-                return siblings[i + 1];
+function pairUp(node, tag) {
+    node.openingElement.selfClosing = false;
+    node.closingElement = {
+        type: 'JSXClosingElement',
+        start: node.end,
+        end: node.end,
+        name: { type: 'JSXIdentifier', name: tag, start: node.end, end: node.end },
+    };
+}
+function printsNothing(child) {
+    const raw = String(child.raw ?? '');
+    return child.type === 'JSXText' && raw.trim() === '' && /[\n\r]/.test(raw);
+}
+function normalizeTagPairs(body, source) {
+    walk(body, (node) => {
+        if (node.type !== 'JSXElement')
+            return;
+        const tag = tagNameOf(node);
+        if (tag === null)
+            return;
+        const children = node.children;
+        const closing = node.closingElement;
+        const component = isComponentName(tag);
+        if (rawTextElements.has(tag) && !component) {
+            if (!closing)
+                pairUp(node, tag);
+            else if (source.slice(node.openingElement.end, closing.start).trim() === '') {
+                children.length = 0;
             }
+            return;
+        }
+        const selfClosable = component || voidElements.has(tag) || tag === 'slot' || hasSetDirective(node);
+        if (children.every(printsNothing) && selfClosable && closing) {
+            node.openingElement.selfClosing = true;
+            node.closingElement = null;
         }
+    });
+}
+function resolveBlankContainers(template, settings) {
+    walk(template, (node) => {
+        if (node.type !== 'JSXElement' && node.type !== 'JSXFragment')
+            return;
+        if (node.type === 'JSXElement' && opensRawSubtree(node))
+            return;
+        const children = node.children;
+        if (children.length === 0)
+            return;
+        const blank = children.every((child) => child.type === 'JSXText' && String(child.raw ?? '').trim() === '');
+        if (!blank)
+            return;
+        const free = blankContentIsFree(node, node.astroRoot === true, settings);
+        children.length = 0;
+        if (!free) {
+            children.push({ type: 'JSXText', start: node.start, end: node.start, raw: ' ', value: ' ' });
+        }
+    });
+}
+function claimChildren(template) {
+    walk(template, (node) => {
+        if (node.type !== 'JSXElement' && node.type !== 'JSXFragment')
+            return;
+        if (node.type === 'JSXElement' && opensRawSubtree(node))
+            return;
+        takeOverChildren(node);
+    });
+}
+function printableComments(root) {
+    const comments = root.comments ?? [];
+    if (comments.length === 0)
+        return comments;
+    const frontmatter = root.frontmatter;
+    const skipped = [];
+    if (frontmatter.end > 0)
+        skipped.push([frontmatter.start, frontmatter.end]);
+    walk(root, (node) => {
+        if (node.astroIgnored) {
+            skipped.push([node.start, node.end]);
+            return;
+        }
+        if (!opensRawSubtree(node))
+            return;
+        const closing = node.closingElement;
+        skipped.push([node.openingElement.end, closing?.start ?? node.end]);
+    });
+    return comments.filter((comment) => !skipped.some(([start, end]) => comment.start >= start && comment.end <= end));
+}
+
+const estree = printers$1.estree;
+
+const { fill, group: group$1, hardline: hardline$2, indent: indent$1, line, softline } = doc.builders;
+const leadingWhitespace = /^[\t\n\f\r ]+/;
+const trailingWhitespace = /[\t\n\f\r ]+$/;
+const whitespaceRun = /[\t\n\f\r ]+/;
+function docFor(separator) {
+    switch (separator) {
+        case 'none':
+            return null;
+        case 'soft':
+            return softline;
+        case 'space':
+            return line;
+        case 'break':
+            return hardline$2;
+        case 'blank':
+            return [hardline$2, hardline$2];
     }
-    return null;
 }
-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)));
+function collect(children, docs) {
+    const items = [];
+    const runs = [];
+    let pending = '';
+    for (const [index, child] of children.entries()) {
+        if (child.type !== 'JSXText') {
+            runs.push(pending);
+            items.push({ node: child, words: null, doc: docs[index] });
+            pending = '';
+            continue;
+        }
+        const raw = String(child.raw ?? '');
+        if (raw.trim() === '') {
+            pending += raw;
+            continue;
+        }
+        const lead = leadingWhitespace.exec(raw)?.[0] ?? '';
+        const trail = trailingWhitespace.exec(raw)?.[0] ?? '';
+        runs.push(pending + lead);
+        items.push({
+            node: child,
+            words: raw.slice(lead.length, raw.length - trail.length).split(whitespaceRun),
+            doc: '',
+        });
+        pending = trail;
+    }
+    runs.push(pending);
+    return { items, runs };
+}
+function printChildren(path, options, print) {
+    const container = path.node;
+    const docs = [];
+    path.each((child) => {
+        docs.push(child.node.type === 'JSXText' ? '' : print());
+    }, 'astroChildren');
+    const { items, runs } = collect(container.astroChildren, docs);
+    if (items.length === 0)
+        return runs[0] === '' ? '' : ' ';
+    const isRoot = container.astroRoot === true;
+    const settings = {
+        mode: options.astroCompressHTML,
+        sensitivity: options.htmlWhitespaceSensitivity,
+    };
+    const separatorAt = (index, edge) => docFor(separatorFor(runs[index], {
+        container,
+        prev: items[index - 1]?.node ?? null,
+        next: items[index]?.node ?? null,
+        isRoot,
+        loneChild: false,
+        edge,
+    }, settings));
+    const parts = [''];
+    const append = (content) => parts.push([parts.pop(), content]);
+    const separate = (separator) => {
+        if (separator !== null)
+            parts.push(separator, '');
+    };
+    for (const [position, item] of items.entries()) {
+        if (position > 0)
+            separate(separatorAt(position, false));
+        if (item.words === null) {
+            append(item.doc);
+            continue;
+        }
+        for (const [wordPosition, word] of item.words.entries()) {
+            if (wordPosition > 0)
+                separate(line);
+            append(word);
+        }
+    }
+    const body = fill(parts);
+    if (isRoot)
+        return body;
+    return group$1([indent$1([separatorAt(0, true) ?? '', body]), separatorAt(items.length, true) ?? '']);
+}
+
+const { group, hardline: hardline$1, indent, join } = doc.builders;
+const { replaceEndOfLine: replaceEndOfLine$1 } = doc.utils;
+const styleParsers = {
+    css: 'css',
+    scss: 'scss',
+    less: 'less',
 };
-function getPreferredQuote(rawContent, preferredQuote) {
-    const double = { quote: '"', regex: /"/g, escaped: '&quot;' };
-    const single = { quote: "'", regex: /'/g, escaped: '&apos;' };
-    const preferred = preferredQuote === "'" ? single : double;
-    const alternate = preferred === single ? double : single;
-    let result = preferred;
-    if (rawContent.includes(preferred.quote) || rawContent.includes(alternate.quote)) {
-        const numPreferredQuotes = (rawContent.match(preferred.regex) || []).length;
-        const numAlternateQuotes = (rawContent.match(alternate.regex) || []).length;
-        result = numPreferredQuotes > numAlternateQuotes ? alternate : preferred;
+async function surfacingErrors(textToDoc, text, options) {
+    try {
+        return await textToDoc(text, options);
+    }
+    catch (error) {
+        process.env.PRETTIER_DEBUG = 'true';
+        throw error;
     }
-    return result;
 }
 function inferParserByTypeAttribute(type) {
-    if (!type) {
-        return 'babel-ts';
-    }
     switch (type) {
+        case null:
         case 'module':
         case 'text/javascript':
         case 'text/babel':
@@ -323,476 +850,213 @@ function inferParserByTypeAttribute(type) {
             return 'babel-ts';
     }
 }
-
-const { builders: { breakParent, dedent, fill, group: group$1, indent: indent$1, join: join$1, line: line$1, softline: softline$1, hardline: hardline$1, literalline, }, utils: { stripTrailingHardline: stripTrailingHardline$1 }, } = _doc;
-let ignoreNext = false;
-function print(path, opts, print) {
+function inferScriptParser(node) {
+    const processed = attributesOf(node).every((attribute) => attribute.type === 'JSXAttribute' && attribute.name.name === 'src');
+    if (processed)
+        return 'babel-ts';
+    return inferParserByTypeAttribute(attributeStringValue(node, 'type'));
+}
+function contentOf(node, options) {
+    const start = node.openingElement.end;
+    const end = node.closingElement?.start ?? node.end;
+    return options.originalText.slice(start, end);
+}
+function wrapContent(print, content, isEmpty) {
+    return [
+        print('openingElement'),
+        indent([hardline$1, content]),
+        isEmpty ? '' : hardline$1,
+        print('closingElement'),
+    ];
+}
+function embedSass(source, options) {
+    const sassOptions = {
+        tabSize: options.tabWidth,
+        insertSpaces: !options.useTabs,
+        lineEnding: options.endOfLine.toUpperCase() === 'CRLF' ? 'CRLF' : 'LF',
+    };
+    const { result } = manualDedent(source);
+    return join(hardline$1, SassFormatter.Format(result, sassOptions).trim().split('\n'));
+}
+function embed(path, options) {
     const node = path.node;
-    if (!node) {
-        return '';
-    }
-    if (ignoreNext && !isEmptyTextNode(node)) {
-        ignoreNext = false;
-        return [
-            opts.originalText
-                .slice(opts.locStart(node), opts.locEnd(node))
-                .split('\n')
-                .map((lineContent, i) => (i == 0 ? [lineContent] : [literalline, lineContent]))
-                .flat(),
+    if (node.astroIgnored)
+        return undefined;
+    if (node.type === 'AstroFrontmatter') {
+        if (node.end === 0 || options.astroSkipFrontmatter)
+            return undefined;
+        const fence = options.originalText.indexOf('---', node.start);
+        const source = options.originalText.slice(fence + 3, node.end - 3);
+        if (!source.trim())
+            return undefined;
+        return async (textToDoc) => [
+            '---',
+            hardline$1,
+            await surfacingErrors(textToDoc, source, { ...options, parser: 'babel-ts' }),
+            hardline$1,
+            '---',
         ];
     }
-    if (typeof node === 'string') {
-        return node;
+    if (node.type !== 'JSXElement')
+        return estree.embed(path, options);
+    const tag = tagNameOf(node);
+    if (tag === null || !node.closingElement)
+        return estree.embed(path, options);
+    const source = contentOf(node, options);
+    const isEmpty = source.trim() === '';
+    if (tag === 'script') {
+        if (isEmpty)
+            return estree.embed(path, options);
+        const parser = inferScriptParser(node);
+        return async (textToDoc, print) => wrapContent(print, await surfacingErrors(textToDoc, source, { ...options, parser }), false);
     }
-    switch (node.type) {
-        case 'root': {
-            return [stripTrailingHardline$1(path.map(print, 'children')), hardline$1];
-        }
-        case 'text': {
-            const rawText = getUnencodedText(node);
-            if (isEmptyTextNode(node)) {
-                const hasWhiteSpace = rawText.trim().length < getUnencodedText(node).length;
-                const hasOneOrMoreNewlines = /\n/.test(getUnencodedText(node));
-                const hasTwoOrMoreNewlines = /\n\r?\s*\n\r?/.test(getUnencodedText(node));
-                if (hasTwoOrMoreNewlines) {
-                    return [hardline$1, hardline$1];
-                }
-                if (hasOneOrMoreNewlines) {
-                    return hardline$1;
-                }
-                if (hasWhiteSpace) {
-                    return line$1;
-                }
-                return '';
-            }
-            return fill(splitTextToDocs(node));
-        }
-        case 'component':
-        case 'fragment':
-        case 'custom-element':
-        case 'element': {
-            let isEmpty;
-            if (!node.children) {
-                isEmpty = true;
-            }
-            else {
-                isEmpty = node.children.every((child) => isEmptyTextNode(child));
-            }
-            const isSelfClosingTag = isEmpty &&
-                (node.type === 'component' ||
-                    selfClosingTags.includes(node.name) ||
-                    hasSetDirectives(node));
-            const isSingleLinePerAttribute = opts.singleAttributePerLine && node.attributes.length > 1;
-            const attributeLine = isSingleLinePerAttribute ? breakParent : '';
-            const attributes = join$1(attributeLine, path.map(print, 'attributes'));
-            if (isSelfClosingTag) {
-                return group$1(['<', node.name, indent$1(attributes), line$1, `/>`]);
-            }
-            if (node.children) {
-                const children = node.children;
-                const firstChild = children[0];
-                const lastChild = children[children.length - 1];
-                let noHugSeparatorStart = softline$1;
-                let noHugSeparatorEnd = softline$1;
-                const hugStart = shouldHugStart(node, opts);
-                const hugEnd = shouldHugEnd(node, opts);
-                let body;
-                if (isEmpty) {
-                    body =
-                        isInlineElement(path, opts, node) &&
-                            node.children.length &&
-                            isTextNodeStartingWithWhitespace(node.children[0]) &&
-                            !isPreTagContent(path)
-                            ? () => line$1
-                            : () => softline$1;
-                }
-                else if (isPreTagContent(path)) {
-                    body = () => printRaw(node);
-                }
-                else if (isInlineElement(path, opts, node) && !isPreTagContent(path)) {
-                    body = () => path.map(print, 'children');
-                }
-                else {
-                    body = () => path.map(print, 'children');
-                }
-                const openingTag = [
-                    '<',
-                    node.name,
-                    indent$1(group$1([
-                        attributes,
-                        hugStart
-                            ? ''
-                            : !isPreTagContent(path) && !opts.bracketSameLine
-                                ? dedent(softline$1)
-                                : '',
-                    ])),
-                ];
-                if (hugStart && hugEnd) {
-                    const huggedContent = [
-                        isSingleLinePerAttribute ? hardline$1 : softline$1,
-                        group$1(['>', body(), `</${node.name}`]),
-                    ];
-                    const omitSoftlineBeforeClosingTag = isEmpty || canOmitSoftlineBeforeClosingTag(path, opts);
-                    return group$1([
-                        ...openingTag,
-                        isEmpty ? group$1(huggedContent) : group$1(indent$1(huggedContent)),
-                        omitSoftlineBeforeClosingTag ? '' : softline$1,
-                        '>',
-                    ]);
-                }
-                if (isPreTagContent(path)) {
-                    noHugSeparatorStart = '';
-                    noHugSeparatorEnd = '';
-                }
-                else {
-                    let didSetEndSeparator = false;
-                    if (!hugStart && firstChild && isTextNode(firstChild)) {
-                        if (isTextNodeStartingWithLinebreak(firstChild) &&
-                            firstChild !== lastChild &&
-                            (!isInlineElement(path, opts, node) || isTextNodeEndingWithWhitespace(lastChild))) {
-                            noHugSeparatorStart = hardline$1;
-                            noHugSeparatorEnd = hardline$1;
-                            didSetEndSeparator = true;
-                        }
-                        else if (isInlineElement(path, opts, node)) {
-                            noHugSeparatorStart = line$1;
-                        }
-                        trimTextNodeLeft(firstChild);
-                    }
-                    if (!hugEnd && lastChild && isTextNode(lastChild)) {
-                        if (isInlineElement(path, opts, node) && !didSetEndSeparator) {
-                            noHugSeparatorEnd = line$1;
-                        }
-                        trimTextNodeRight(lastChild);
-                    }
-                }
-                if (hugStart) {
-                    return group$1([
-                        ...openingTag,
-                        indent$1([softline$1, group$1(['>', body()])]),
-                        noHugSeparatorEnd,
-                        `</${node.name}>`,
-                    ]);
-                }
-                if (hugEnd) {
-                    return group$1([
-                        ...openingTag,
-                        '>',
-                        indent$1([noHugSeparatorStart, group$1([body(), `</${node.name}`])]),
-                        canOmitSoftlineBeforeClosingTag(path, opts) ? '' : softline$1,
-                        '>',
-                    ]);
-                }
-                if (isEmpty) {
-                    return group$1([...openingTag, '>', body(), `</${node.name}>`]);
-                }
-                return group$1([
-                    ...openingTag,
-                    '>',
-                    indent$1([noHugSeparatorStart, body()]),
-                    noHugSeparatorEnd,
-                    `</${node.name}>`,
-                ]);
-            }
-            return '';
-        }
-        case 'attribute': {
-            const name = node.name.trim();
-            switch (node.kind) {
-                case 'empty':
-                    return [line$1, name];
-                case 'expression':
-                    return '';
-                case 'quoted':
-                    let value = node.value;
-                    if (node.name === 'class') {
-                        value = printClassNames(value);
-                    }
-                    const unescapedValue = value.replace(/&apos;/g, "'").replace(/&quot;/g, '"');
-                    const { escaped, quote, regex } = getPreferredQuote(unescapedValue, opts.jsxSingleQuote ? "'" : '"');
-                    const result = unescapedValue.replace(regex, escaped);
-                    return [line$1, name, '=', quote, result, quote];
-                case 'shorthand':
-                    return [line$1, '{', name, '}'];
-                case 'spread':
-                    return [line$1, '{...', name, '}'];
-                case 'template-literal':
-                    return [line$1, name, '=', '`', node.value, '`'];
-            }
-            return '';
-        }
-        case 'doctype': {
-            return ['<!doctype html>', hardline$1];
-        }
-        case 'comment':
-            if (isIgnoreDirective(node)) {
-                ignoreNext = true;
-            }
-            const nextNode = getNextNode(path);
-            let trailingLine = '';
-            if (nextNode && isTagLikeNode(nextNode)) {
-                trailingLine = hardline$1;
-            }
-            return ['<!--', getUnencodedText(node), '-->', trailingLine];
-        default: {
-            throw new Error(`Unhandled node type "${node.type}"!`);
+    if (tag === 'style') {
+        if (isEmpty)
+            return estree.embed(path, options);
+        const lang = attributeStringValue(node, 'lang')?.toLowerCase() ?? 'css';
+        if (lang === 'sass') {
+            return (_textToDoc, print) => wrapContent(print, embedSass(source, options), false);
         }
+        const parser = styleParsers[lang];
+        if (!parser)
+            return printVerbatim(source);
+        return async (textToDoc, print) => wrapContent(print, await surfacingErrors(textToDoc, source, { ...options, parser }), false);
     }
-}
-function splitTextToDocs(node) {
-    const text = getUnencodedText(node);
-    const textLines = text.split(/[\t\n\f\r ]+/);
-    let docs = join$1(line$1, textLines).filter((doc) => doc !== '');
-    if (startsWithLinebreak(text)) {
-        docs[0] = hardline$1;
-    }
-    if (startsWithLinebreak(text, 2)) {
-        docs = [hardline$1, ...docs];
-    }
-    if (endsWithLinebreak(text)) {
-        docs[docs.length - 1] = hardline$1;
-    }
-    if (endsWithLinebreak(text, 2)) {
-        docs = [...docs, hardline$1];
+    if (opensRawSubtree(node)) {
+        return (_textToDoc, print) => [
+            print('openingElement'),
+            replaceEndOfLine$1(source),
+            print('closingElement'),
+        ];
     }
-    return docs;
+    return estree.embed(path, options);
+}
+function printVerbatim(source) {
+    return (_textToDoc, print) => group([print('openingElement'), replaceEndOfLine$1(source), print('closingElement')]);
 }
 
-const { builders: { group, indent, join, line, softline, hardline, lineSuffixBoundary }, utils: { stripTrailingHardline, mapDoc }, } = _doc;
-const supportedStyleLangValues = ['css', 'scss', 'sass', 'less'];
-const embed = ((path, options) => {
-    const parserOption = options;
-    return async (textToDoc, print) => {
-        const node = path.node;
-        if (!node)
-            return undefined;
-        if (node.type === 'expression') {
-            const jsxNode = makeNodeJSXCompatible(node);
-            const textContent = printRaw(jsxNode);
-            let content;
-            content = await wrapParserTryCatch(textToDoc, textContent, {
-                ...options,
-                parser: 'astroExpressionParser',
-            });
-            content = stripTrailingHardline(content);
-            const strings = [];
-            mapDoc(content, (doc) => {
-                if (typeof doc === 'string') {
-                    strings.push(doc);
-                }
-            });
-            if (strings.every((value) => value.startsWith('//'))) {
-                return group(['{', content, softline, lineSuffixBoundary, '}']);
-            }
-            const astroDoc = mapDoc(content, (doc) => {
-                if (typeof doc === 'string') {
-                    doc = doc.replaceAll(openingBracketReplace, '{');
-                    doc = doc.replaceAll(closingBracketReplace, '}');
-                    doc = doc.replaceAll(atSignReplace, '@');
-                    doc = doc.replaceAll(dotReplace, '.');
-                    doc = doc.replaceAll(interrogationReplace, '?');
-                }
-                return doc;
-            });
-            return group(['{', indent([softline, astroDoc]), softline, lineSuffixBoundary, '}']);
-        }
-        if (node.type === 'attribute' && node.kind === 'expression') {
-            const value = node.value.trim();
-            const name = node.name.trim();
-            const attrNodeValue = await wrapParserTryCatch(textToDoc, value, {
-                ...options,
-                parser: 'astroExpressionParser',
-            });
-            if (name === value && options.astroAllowShorthand) {
-                return [line, '{', attrNodeValue, '}'];
+const { hardline } = doc.builders;
+const { replaceEndOfLine } = doc.utils;
+function printDoctype(value) {
+    const trimmed = value.trim();
+    const space = trimmed.search(/\s/);
+    const name = space === -1 ? trimmed : trimmed.slice(0, space);
+    const rest = space === -1 ? '' : trimmed.slice(space);
+    return `<!doctype ${name.toLowerCase()}${rest}>`;
+}
+function printAstroNode(path, options, print) {
+    const node = path.node;
+    switch (node.type) {
+        case 'AstroRoot': {
+            const template = node.template;
+            const hasTemplate = template.node.children.length > 0;
+            const parts = [];
+            if (node.frontmatter.end > 0) {
+                parts.push(print('frontmatter'));
+                if (hasTemplate)
+                    parts.push(hardline, hardline);
             }
-            return [line, name, '=', '{', attrNodeValue, '}'];
-        }
-        if (node.type === 'attribute' && node.kind === 'spread') {
-            const spreadContent = await wrapParserTryCatch(textToDoc, node.name, {
-                ...options,
-                parser: 'astroExpressionParser',
-            });
-            return [line, '{...', spreadContent, '}'];
+            if (hasTemplate)
+                parts.push(print('template'));
+            return [parts, hardline];
         }
-        if (node.type === 'frontmatter') {
+        case 'AstroFrontmatter': {
+            const body = node.program.body;
             if (options.astroSkipFrontmatter) {
-                return [group(['---', node.value, '---', hardline]), hardline];
-            }
-            const frontmatterContent = await wrapParserTryCatch(textToDoc, node.value, {
-                ...options,
-                parser: 'babel-ts',
-            });
-            return [group(['---', hardline, frontmatterContent, hardline, '---', hardline]), hardline];
-        }
-        if (node.type === 'element' && node.name === 'script' && node.children.length) {
-            const typeAttribute = node.attributes.find((attr) => attr.name === 'type')?.value;
-            let parser = 'babel-ts';
-            if (typeAttribute) {
-                parser = inferParserByTypeAttribute(typeAttribute);
-            }
-            const scriptContent = printRaw(node);
-            let formattedScript = await wrapParserTryCatch(textToDoc, scriptContent, {
-                ...options,
-                parser: parser,
-            });
-            formattedScript = stripTrailingHardline(formattedScript);
-            const isEmpty = /^\s*$/.test(scriptContent);
-            const attributes = path.map(print, 'attributes');
-            const openingTag = group(['<script', indent(group(attributes)), softline, '>']);
-            return [
-                openingTag,
-                indent([isEmpty ? '' : hardline, formattedScript]),
-                isEmpty ? '' : hardline,
-                '</script>',
-            ];
-        }
-        if (node.type === 'element' && node.name === 'style') {
-            const content = printRaw(node);
-            let parserLang = 'css';
-            if (node.attributes) {
-                const langAttribute = node.attributes.filter((x) => x.name === 'lang');
-                if (langAttribute.length) {
-                    const styleLang = langAttribute[0].value.toLowerCase();
-                    parserLang = supportedStyleLangValues.includes(styleLang) ? styleLang : undefined;
-                }
+                const fence = options.originalText.indexOf('---', node.start);
+                return replaceEndOfLine(options.originalText.slice(fence, node.end));
             }
-            return await embedStyle(parserLang, content, path, print, textToDoc, parserOption);
+            return body.length > 0
+                ? ['---', hardline, print('program'), '---']
+                : ['---', hardline, '---'];
         }
-        return undefined;
-    };
-});
-async function wrapParserTryCatch(cb, text, options) {
-    try {
-        return await cb(text, options);
-    }
-    catch (e) {
-        process.env.PRETTIER_DEBUG = 'true';
-        throw e;
+        case 'AstroScript':
+            return node.program.body.length > 0 ? print('program') : '';
+        case 'AstroDoctype':
+            return printDoctype(node.value);
+        case 'AstroComment':
+            return `<!--${node.value}-->`;
+        default:
+            return '';
     }
 }
-function makeNodeJSXCompatible(node) {
-    const newNode = { ...node };
-    const childBundle = [];
-    let childBundleIndex = 0;
-    if (isNodeWithChildren(newNode)) {
-        newNode.children = newNode.children.reduce((result, child, index) => {
-            const previousChildren = newNode.children[index - 1];
-            const nextChildren = newNode.children[index + 1];
-            if (isTagLikeNode(child)) {
-                child.attributes = child.attributes.map(makeAttributeJSXCompatible);
-                if (!childBundle[childBundleIndex]) {
-                    childBundle[childBundleIndex] = [];
-                }
-                if (isNodeWithChildren(child)) {
-                    child = makeNodeJSXCompatible(child);
-                }
-                if ((!previousChildren || isTextNode(previousChildren)) &&
-                    nextChildren &&
-                    isTagLikeNode(nextChildren)) {
-                    childBundle[childBundleIndex].push(child);
-                    return result;
-                }
-                if (previousChildren &&
-                    isTagLikeNode(previousChildren) &&
-                    nextChildren &&
-                    isTagLikeNode(nextChildren)) {
-                    childBundle[childBundleIndex].push(child);
-                    return result;
-                }
-                if ((!nextChildren || isTextNode(nextChildren)) &&
-                    childBundle[childBundleIndex].length > 0) {
-                    childBundle[childBundleIndex].push(child);
-                    const parentNode = {
-                        type: 'fragment',
-                        name: '',
-                        attributes: [],
-                        children: childBundle[childBundleIndex],
-                    };
-                    childBundleIndex += 1;
-                    result.push(parentNode);
-                    return result;
-                }
-            }
-            else {
-                childBundleIndex += 1;
-            }
-            result.push(child);
-            return result;
-        }, []);
+function printAttribute(path, options, print) {
+    const node = path.node;
+    const name = node.name.name;
+    const value = node.value;
+    if (node.astroShorthand)
+        return ['{', print(['value', 'expression']), '}'];
+    if (node.astroBacktick)
+        return [name, '=', print(['value', 'expression'])];
+    const expression = value?.type === 'JSXExpressionContainer' ? value.expression : null;
+    if (options.astroAllowShorthand &&
+        expression?.type === 'Identifier' &&
+        expression.name === name) {
+        return ['{', print(['value', 'expression']), '}'];
     }
-    return newNode;
-    function makeAttributeJSXCompatible(attr) {
-        if (attr.kind === 'shorthand') {
-            attr.kind = 'empty';
-            attr.name = openingBracketReplace + attr.name + closingBracketReplace;
-        }
-        if (attr.kind !== 'spread') {
-            if (attr.name.includes('@')) {
-                attr.name = attr.name.replaceAll('@', atSignReplace);
-            }
-            if (attr.name.includes('.')) {
-                attr.name = attr.name.replaceAll('.', dotReplace);
-            }
-            if (attr.name.includes('?')) {
-                attr.name = attr.name.replaceAll('?', interrogationReplace);
-            }
-        }
-        return attr;
+    return null;
+}
+function unwrapFragmentIndent(printed) {
+    const group = printed;
+    if (group.type !== 'group')
+        return printed;
+    if (group.expandedStates) {
+        const states = group.expandedStates.map(unwrapFragmentIndent);
+        return { ...group, contents: states[0], expandedStates: states };
     }
+    const parts = group.contents;
+    if (!Array.isArray(parts) || parts.length !== 4)
+        return printed;
+    const indented = parts[1];
+    if (indented.type !== 'indent' || !indented.contents)
+        return printed;
+    return indented.contents[1];
 }
-async function embedStyle(lang, content, path, print, textToDoc, options) {
-    const isEmpty = /^\s*$/.test(content);
-    switch (lang) {
-        case 'less':
-        case 'css':
-        case 'scss': {
-            let formattedStyles = await wrapParserTryCatch(textToDoc, content, {
-                ...options,
-                parser: lang,
-            });
-            formattedStyles = stripTrailingHardline(formattedStyles);
-            const attributes = path.map(print, 'attributes');
-            const openingTag = group(['<style', indent(group(attributes)), softline, '>']);
-            return [
-                openingTag,
-                indent([isEmpty ? '' : hardline, formattedStyles]),
-                isEmpty ? '' : hardline,
-                '</style>',
-            ];
+const printer = {
+    ...estree,
+    embed,
+    getVisitorKeys(node, nonTraversableKeys) {
+        const keys = astroVisitorKeys[node.type] ?? estree.getVisitorKeys(node, nonTraversableKeys);
+        return node.astroChildren
+            ? keys.map((key) => (key === 'children' ? 'astroChildren' : key))
+            : keys;
+    },
+    print(path, options, print, args) {
+        const node = path.node;
+        if (node[ownChildren])
+            return path.callParent(() => printChildren(path, options, print));
+        if (node[synthetic])
+            return '';
+        if (node.astroIgnored) {
+            return replaceEndOfLine(options.originalText.slice(node.start, node.end));
+        }
+        if (astroVisitorKeys[node.type])
+            return printAstroNode(path, options, print);
+        if (node.type === 'JSXAttribute') {
+            const attribute = printAttribute(path, options, print);
+            if (attribute)
+                return attribute;
         }
-        case 'sass': {
-            const lineEnding = options?.endOfLine?.toUpperCase() === 'CRLF' ? 'CRLF' : 'LF';
-            const sassOptions = {
-                tabSize: options.tabWidth,
-                insertSpaces: !options.useTabs,
-                lineEnding,
-            };
-            const { result: raw } = manualDedent(content);
-            const formattedSassIndented = SassFormatter.Format(raw, sassOptions).trim();
-            const formattedSass = join(hardline, formattedSassIndented.split('\n'));
-            const attributes = path.map(print, 'attributes');
-            const openingTag = group(['<style', indent(group(attributes)), softline, '>']);
+        if (node.type === 'JSXElement' &&
+            node.closingElement &&
+            node.children.length > 0 &&
+            opensRawSubtree(node)) {
+            const start = node.openingElement.end;
+            const end = node.closingElement.start;
             return [
-                openingTag,
-                indent([isEmpty ? '' : hardline, formattedSass]),
-                isEmpty ? '' : hardline,
-                '</style>',
+                print('openingElement'),
+                replaceEndOfLine(options.originalText.slice(start, end)),
+                print('closingElement'),
             ];
         }
-        case undefined: {
-            const node = path.getNode();
-            if (node) {
-                return Buffer.from(options.originalText)
-                    .subarray(options.locStart(node), options.locEnd(node))
-                    .toString();
-            }
-            return undefined;
+        const printed = estree.print(path, options, print, args);
+        if (node.openingFragment?.[synthetic]) {
+            return unwrapFragmentIndent(printed);
         }
-    }
-}
+        return printed;
+    },
+};
 
-const babelParser = prettierPluginBabel.parsers['babel-ts'];
 const languages = [
     {
         name: 'astro',
@@ -803,30 +1067,14 @@ const languages = [
 ];
 const parsers = {
     astro: {
-        parse: (source) => parse(source, { position: true }).ast,
+        parse,
         astFormat: 'astro',
-        locStart: (node) => node.position.start.offset,
-        locEnd: (node) => node.position.end.offset,
-    },
-    astroExpressionParser: {
-        ...babelParser,
-        preprocess(text) {
-            return `<>{${text}\n}</>`;
-        },
-        parse(text, opts) {
-            const ast = babelParser.parse(text, opts);
-            return {
-                ...ast,
-                program: ast.program.body[0].expression.children[0].expression,
-            };
-        },
+        locStart: (node) => node.start,
+        locEnd: (node) => node.end,
     },
 };
 const printers = {
-    astro: {
-        print,
-        embed,
-    },
+    astro: printer,
 };
 const defaultOptions = {
     tabWidth: 2,