prettier-plugin-astro 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/index.js

@@ -1,4 +1,5 @@
 import { parse as parse$1 } from '@astrojs/compiler-rs';
+import parseSrcset from '@prettier/parse-srcset';
 import { doc } from 'prettier';
 import { printers as printers$1 } from 'prettier/plugins/estree';
 import { SassFormatter } from 'sass-formatter';
@@ -53,6 +54,15 @@ function tagNameOf(node) {
     const name = node.openingElement?.name;
     return name?.type === 'JSXIdentifier' ? name.name : null;
 }
+function jsxNameOf(name) {
+    if (name.type === 'JSXIdentifier')
+        return name.name;
+    if (name.type !== 'JSXMemberExpression')
+        return null;
+    const object = jsxNameOf(name.object);
+    const property = jsxNameOf(name.property);
+    return object !== null && property !== null ? `${object}.${property}` : null;
+}
 const isComponentName = (name) => name === null || /^[A-Z]/.test(name) || name.includes('.');
 function attributesOf(node) {
     const opening = node.openingElement;
@@ -242,19 +252,20 @@ function isInlineDisplay(display) {
     return inlineLevel.has(display);
 }
 
+const { group: group$3, ifBreak, indent: indent$3, join: join$1, line: line$2, softline: softline$3 } = doc.builders;
 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)
+    for (const row of result.split('\n')) {
+        if (!row)
             continue;
-        if (line[0] && /^\S/.test(line[0])) {
+        if (row[0] && /^\S/.test(row[0])) {
             minTabSize = 0;
             break;
         }
-        const match = /^(\s+)\S+/.exec(line);
+        const match = /^(\s+)\S+/.exec(row);
         if (match) {
             if (match[1] && !char)
                 char = match[1][0];
@@ -271,11 +282,39 @@ function manualDedent(input) {
         result,
     };
 }
+function printSrcset(value) {
+    const candidates = parseSrcset(decodeQuoteEntities(value));
+    const descriptorUnits = { width: 'w', height: 'h', density: 'x' };
+    const descriptorTypes = Object.keys(descriptorUnits).filter((type) => candidates.some((candidate) => candidate[type]));
+    if (descriptorTypes.length > 1)
+        throw new Error('Mixed descriptor in srcset is not supported');
+    const descriptorType = descriptorTypes[0];
+    const unit = descriptorType ? descriptorUnits[descriptorType] : '';
+    const urls = candidates.map((candidate) => candidate.source.value);
+    const widestUrl = Math.max(...urls.map((url) => url.length));
+    const descriptors = candidates.map((candidate) => descriptorType && candidate[descriptorType] ? String(candidate[descriptorType].value) : '');
+    const descriptorLeftLengths = descriptors.map((descriptor) => {
+        const decimal = descriptor.indexOf('.');
+        return decimal === -1 ? descriptor.length : decimal;
+    });
+    const widestDescriptorLeft = Math.max(...descriptorLeftLengths);
+    const printed = urls.map((url, index) => {
+        const parts = [url.replaceAll('"', '"')];
+        const descriptor = descriptors[index];
+        if (descriptor) {
+            const padding = widestUrl - url.length + 1 + widestDescriptorLeft - descriptorLeftLengths[index];
+            parts.push(ifBreak(' '.repeat(padding), ' '), descriptor + unit);
+        }
+        return parts;
+    });
+    return group$3([indent$3([softline$3, join$1([',', line$2], printed)]), softline$3]);
+}
+const decodeQuoteEntities = (text) => text.replaceAll(''', "'").replaceAll('"', '"');
 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(' ');
+    const formattedLines = lines.map((row) => {
+        const spaces = /^\s+/.exec(row);
+        return (spaces ? spaces[0] : '') + row.trim().split(/\s+/).join(' ');
     });
     return formattedLines.join('\n');
 }
@@ -284,11 +323,14 @@ 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 isComment = (node) => node?.type === 'AstroComment';
 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 (node.astroPreserveWhitespace)
+        return true;
     if (hasAttribute(node, 'is:raw'))
         return true;
     const tag = tagNameOf(node);
@@ -301,9 +343,62 @@ function displayOf(node) {
     const tag = tagNameOf(node);
     if (tag === null || isComponentName(tag) || tag.includes('-'))
         return 'inline';
+    if (node.astroSvg)
+        return tag === 'svg' ? 'inline-block' : node.astroSvgText ? 'inline' : 'block';
     return displayOfTag(tag);
 }
+const isBlockBox = (node) => node !== null && node.type !== 'JSXText' && !isInlineDisplay(displayOf(node));
+const swallowsEdgeWhitespace = (node) => {
+    const display = displayOf(node);
+    return display === 'inline-block' || !isInlineDisplay(display);
+};
+const breaksOwnChildren = new Set(['html', 'head', 'ul', 'ol', 'select']);
+const breaksOwnContent = new Set(['body', 'script', 'style']);
+function breaksChildren(node) {
+    const tag = node.type === 'JSXElement' ? tagNameOf(node) : null;
+    if (tag === null || isComponentName(tag))
+        return false;
+    if (breaksOwnChildren.has(tag))
+        return true;
+    const display = displayOfTag(tag);
+    return display.startsWith('table') && display !== 'table-cell';
+}
+const hasElementChild = (node) => childrenOf(node)?.some((child) => child.type === 'JSXElement') ?? false;
+const runBefore = (node) => node && isText(node) ? (trailingWhitespace$1.exec(rawTextOf(node))?.[0] ?? '') : '';
+const runAfter = (node) => node && isText(node) ? (leadingWhitespace$1.exec(rawTextOf(node))?.[0] ?? '') : '';
+function sitsOnItsOwnLine(container, child) {
+    if (child === null || isText(child))
+        return false;
+    const children = childrenOf(container);
+    const index = children?.indexOf(child) ?? -1;
+    if (index === -1)
+        return false;
+    return hasNewline(runBefore(children[index - 1])) && hasNewline(runAfter(children[index + 1]));
+}
+const hasChildOnItsOwnLine = (node) => childrenOf(node)?.some((child) => sitsOnItsOwnLine(node, child)) ?? false;
+function forcesBreak(node) {
+    if (breaksChildren(node))
+        return true;
+    const children = childrenOf(node);
+    if (children === null)
+        return false;
+    const tag = node.type === 'JSXElement' ? tagNameOf(node) : null;
+    if (tag !== null && breaksOwnContent.has(tag))
+        return true;
+    return children.some(hasElementChild) || hasChildOnItsOwnLine(node);
+}
 const isBlankRun = (run) => /[\n\r][^\S\n\r]*[\n\r]/.test(run);
+const isEmptySlot = (node) => node.type === 'JSXElement' && tagNameOf(node) === 'slot' && (childrenOf(node)?.length ?? 0) === 0;
+function canRenderEmpty(container) {
+    const tag = container.type === 'JSXElement' ? tagNameOf(container) : null;
+    if (tag === null || isComponentName(tag))
+        return false;
+    const children = childrenOf(container);
+    if (children === null)
+        return false;
+    const content = children.filter((child) => !isWhitespaceOnly(child) && !isComment(child));
+    return (children.some((child) => isComment(child) || isEmptySlot(child)) && content.every(isEmptySlot));
+}
 function sidesFor(boundary) {
     if (boundary.edge)
         return [null];
@@ -318,7 +413,7 @@ function sidesFor(boundary) {
         sides.push(boundary.next);
     return sides.length > 0 ? sides : null;
 }
-function blankContentIsFree(container, run, isRoot, settings) {
+function blankContentIsFree(container, isRoot, settings) {
     const tag = container.type === 'JSXElement' ? tagNameOf(container) : null;
     if (tag === 'slot')
         return false;
@@ -352,16 +447,26 @@ function separatorFor(run, boundary, settings) {
         return run === '' ? 'none' : 'space';
     const free = isFree(internal) || (sides !== null && mayAlterRenderedWhitespace(internal));
     if (boundary.edge) {
+        if (settings.sensitivity !== 'ignore' && canRenderEmpty(boundary.container)) {
+            return run === '' ? 'none' : 'space';
+        }
         if (free)
             return 'soft';
         return run === '' ? 'none' : 'space';
     }
     if (isBlankRun(run))
         return 'blank';
-    if (hasNewline(run))
+    if (settings.sensitivity === 'ignore')
+        return 'break';
+    if (hasNewline(run) &&
+        (sitsOnItsOwnLine(boundary.container, boundary.prev) ||
+            sitsOnItsOwnLine(boundary.container, boundary.next))) {
+        return 'break';
+    }
+    if (run !== '' && (isComment(boundary.prev) || isComment(boundary.next)))
         return 'break';
     if (free)
-        return 'soft';
+        return isBlockBox(boundary.prev) || isBlockBox(boundary.next) ? 'break' : 'soft';
     return run === '' ? 'none' : 'space';
 }
 function normalizeWhitespace(template, options) {
@@ -455,6 +560,8 @@ function decide(run, boundary) {
     const { mode } = boundary.context;
     if (isSlotFallback(boundary))
         return 'space';
+    if (boundary.context.sensitivity !== 'ignore' && canRenderEmpty(boundary.container))
+        return 'keep';
     if (isFree(boundary))
         return 'drop';
     if (mayAlterRenderedWhitespace(boundary))
@@ -475,11 +582,11 @@ function isFree(boundary) {
     const tag = container.type === 'JSXElement' ? tagNameOf(container) : null;
     if (loneChild && tag !== null && isComponentName(tag))
         return true;
+    if (context.sensitivity !== 'strict' && breaksChildren(container))
+        return true;
     if (mode === 'html') {
         if (loneChild)
             return true;
-        if (tag === 'head')
-            return true;
     }
     return false;
 }
@@ -489,7 +596,7 @@ function mayAlterRenderedWhitespace(boundary) {
         return true;
     if (sensitivity === 'strict')
         return false;
-    return boundary.sides.every((side) => !isInlineDisplay(displayOf(side ?? boundary.container)));
+    return boundary.sides.some((side) => side === null ? swallowsEdgeWhitespace(boundary.container) : isBlockBox(side));
 }
 function isSlotFallback(boundary) {
     return (boundary.container.type === 'JSXElement' &&
@@ -502,9 +609,10 @@ function parse(source, options) {
     const failure = diagnostics.find((diagnostic) => diagnostic.severity === 'error');
     if (failure)
         throw syntaxError(failure);
-    stripParenthesizedExpressions(ast);
+    stripParentheses(ast);
     repairSpans(ast);
     markAttributes(ast, source);
+    markSvgNamespace(ast);
     applyPrettierIgnore(ast);
     const body = ast.body;
     const template = templateFragment(ast, body);
@@ -532,7 +640,7 @@ function syntaxError(diagnostic) {
     error.loc = { start: { line, column } };
     return error;
 }
-function stripParenthesizedExpressions(root) {
+function stripParentheses(root) {
     walk(root, (node) => {
         for (const key of Object.keys(node)) {
             const value = node[key];
@@ -549,8 +657,13 @@ function stripParenthesizedExpressions(root) {
 }
 function unwrapParens(node) {
     let current = node;
-    while (isNode(current) && current.type === 'ParenthesizedExpression') {
-        current = current.expression;
+    while (isNode(current)) {
+        if (current.type === 'ParenthesizedExpression')
+            current = current.expression;
+        else if (current.type === 'TSParenthesizedType')
+            current = current.typeAnnotation;
+        else
+            break;
     }
     return current;
 }
@@ -567,28 +680,43 @@ function repairSpans(root) {
 }
 function markAttributes(root, source) {
     walk(root, (node) => {
-        if (node.type !== 'JSXAttribute')
-            return;
-        const value = node.value;
-        if (!value)
+        if (node.type !== 'JSXElement')
             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('"', '"')}"`;
+        const tag = tagNameOf(node);
+        const htmlElement = tag !== null && !isComponentName(tag);
+        for (const attribute of attributesOf(node)) {
+            if (attribute.type !== 'JSXAttribute')
+                continue;
+            const name = String(attribute.name.name).toLowerCase();
+            if (htmlElement && name === 'style')
+                attribute.astroStyleAttribute = true;
+            if ((tag === 'img' || tag === 'source') && name === 'srcset') {
+                attribute.astroSrcsetAttribute = true;
             }
-            return;
+            markAttribute(attribute, source);
         }
-        if (value.type !== 'JSXExpressionContainer')
-            return;
-        if (source[node.start] === '{')
-            node.astroShorthand = true;
-        if (source[value.start] === '`')
-            node.astroBacktick = true;
     });
 }
+function markAttribute(node, source) {
+    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('"', '"')}"`;
+        }
+        return;
+    }
+    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);
@@ -605,6 +733,28 @@ function applyPrettierIgnore(root) {
         }
     });
 }
+const svgTextElements = new Set(['text', 'textPath', 'tspan']);
+function markSvgNamespace(root) {
+    const mark = (node, inText = false, inheritedPreserve = false) => {
+        node.astroSvg = true;
+        const textContent = inText || svgTextElements.has(tagNameOf(node) ?? '');
+        const whitespace = attributeStringValue(node, 'xml:space');
+        const preserve = whitespace === 'preserve' || (inheritedPreserve && whitespace !== 'default');
+        if (textContent)
+            node.astroSvgText = true;
+        if (textContent && preserve)
+            node.astroPreserveWhitespace = true;
+        for (const child of childrenOf(node) ?? []) {
+            if (child.type !== 'JSXElement' || tagNameOf(child) === 'foreignObject')
+                continue;
+            mark(child, textContent, preserve);
+        }
+    };
+    walk(root, (node) => {
+        if (node.type === 'JSXElement' && tagNameOf(node) === 'svg')
+            mark(node);
+    });
+}
 function templateFragment(root, body) {
     const start = body[0]?.start ?? root.end;
     const end = body.at(-1)?.end ?? root.end;
@@ -673,8 +823,7 @@ function resolveBlankContainers(template, settings) {
         const blank = children.every((child) => child.type === 'JSXText' && String(child.raw ?? '').trim() === '');
         if (!blank)
             return;
-        const run = children.map((child) => String(child.raw ?? '')).join('');
-        const free = blankContentIsFree(node, run, node.astroRoot === true, settings);
+        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: ' ' });
@@ -713,32 +862,38 @@ function printableComments(root) {
 
 const estree = printers$1.estree;
 
-const { fill, group: group$1, hardline: hardline$2, indent: indent$1, line, softline } = doc.builders;
+const { fill, group: group$2, hardline: hardline$2, indent: indent$2, line: line$1, softline: softline$2 } = doc.builders;
 const leadingWhitespace = /^[\t\n\f\r ]+/;
 const trailingWhitespace = /[\t\n\f\r ]+$/;
 const whitespaceRun = /[\t\n\f\r ]+/;
+const lends = 'lends-closing-bracket';
+const withholdsClosingBracket = (node) => node.type === 'JSXElement' &&
+    !node.astroIgnored &&
+    Boolean(node.closingElement) &&
+    Boolean(node.astroChildren) &&
+    !opensRawSubtree(node);
 function docFor(separator) {
     switch (separator) {
         case 'none':
             return null;
         case 'soft':
-            return softline;
+            return softline$2;
         case 'space':
-            return line;
+            return line$1;
         case 'break':
             return hardline$2;
         case 'blank':
             return [hardline$2, hardline$2];
     }
 }
-function collect(children, docs) {
+function collect(children) {
     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] });
+            items.push({ node: child, index, words: null, doc: '' });
             pending = '';
             continue;
         }
@@ -752,6 +907,7 @@ function collect(children, docs) {
         runs.push(pending + lead);
         items.push({
             node: child,
+            index,
             words: raw.slice(lead.length, raw.length - trail.length).split(whitespaceRun),
             doc: '',
         });
@@ -760,13 +916,11 @@ function collect(children, docs) {
     runs.push(pending);
     return { items, runs };
 }
-function printChildren(path, options, print) {
+function printChildren(path, options, print, childrenOptions = {}) {
+    const { mode, suffix } = childrenOptions;
     const container = path.node;
-    const docs = [];
-    path.each((child) => {
-        docs.push(child.node.type === 'JSXText' ? '' : print());
-    }, 'astroChildren');
-    const { items, runs } = collect(container.astroChildren, docs);
+    const children = container.astroChildren;
+    const { items, runs } = collect(children);
     if (items.length === 0)
         return runs[0] === '' ? '' : ' ';
     const isRoot = container.astroRoot === true;
@@ -782,6 +936,28 @@ function printChildren(path, options, print) {
         loneChild: false,
         edge,
     }, settings));
+    const lenders = new Set();
+    const lending = new Set();
+    for (let position = 1; position < items.length; position++) {
+        if (separatorAt(position, false) !== null)
+            continue;
+        if (!withholdsClosingBracket(items[position - 1].node))
+            continue;
+        lenders.add(position);
+        lending.add(items[position - 1].index);
+    }
+    if (mode === 'fill-lending')
+        lending.add(items.at(-1).index);
+    const printed = new Map();
+    path.each((child, index) => {
+        if (child.node.type === 'JSXText')
+            return;
+        printed.set(index, print(undefined, lending.has(index) ? lends : undefined));
+    }, 'astroChildren');
+    for (const item of items) {
+        if (item.words === null)
+            item.doc = printed.get(item.index) ?? '';
+    }
     const parts = [''];
     const append = (content) => parts.push([parts.pop(), content]);
     const separate = (separator) => {
@@ -789,26 +965,41 @@ function printChildren(path, options, print) {
             parts.push(separator, '');
     };
     for (const [position, item] of items.entries()) {
-        if (position > 0)
-            separate(separatorAt(position, false));
+        if (position > 0) {
+            if (lenders.has(position)) {
+                parts.push(softline$2, '');
+                append('>');
+            }
+            else
+                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);
+                separate(line$1);
             append(word);
         }
     }
+    if (suffix)
+        append(suffix);
     const body = fill(parts);
-    if (isRoot)
+    if (isRoot || mode === 'fill' || mode === 'fill-lending')
         return body;
-    return group$1([indent$1([separatorAt(0, true) ?? '', body]), separatorAt(items.length, true) ?? '']);
+    const content = [
+        indent$2([separatorAt(0, true) ?? '', body]),
+        separatorAt(items.length, true) ?? '',
+    ];
+    if (mode === 'loose')
+        return content;
+    return group$2(content, { shouldBreak: forcesBreak(container) });
 }
 
-const { group, hardline: hardline$1, indent, join } = doc.builders;
-const { replaceEndOfLine: replaceEndOfLine$1 } = doc.utils;
+const { group: group$1, hardline: hardline$1, indent: indent$1, join, softline: softline$1 } = doc.builders;
+const { mapDoc, replaceEndOfLine: replaceEndOfLine$1 } = doc.utils;
+const escapeQuotes = (value) => mapDoc(value, (part) => (typeof part === 'string' ? part.replaceAll('"', '&quot;') : part));
 const styleParsers = {
     css: 'css',
     scss: 'scss',
@@ -846,6 +1037,20 @@ function inferParserByTypeAttribute(type) {
             return 'babel-ts';
     }
 }
+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 styleAttributeValue(node) {
+    if (!node.astroStyleAttribute)
+        return null;
+    const value = node.value;
+    if (value?.type !== 'Literal' || typeof value.value !== 'string')
+        return null;
+    return value.value.trim() === '' ? null : value.value;
+}
 function contentOf(node, options) {
     const start = node.openingElement.end;
     const end = node.closingElement?.start ?? node.end;
@@ -854,7 +1059,7 @@ function contentOf(node, options) {
 function wrapContent(print, content, isEmpty) {
     return [
         print('openingElement'),
-        indent([isEmpty ? '' : hardline$1, content]),
+        indent$1([hardline$1, content]),
         isEmpty ? '' : hardline$1,
         print('closingElement'),
     ];
@@ -887,6 +1092,20 @@ function embed(path, options) {
             '---',
         ];
     }
+    if (node.type === 'JSXAttribute' && options.astroCompressHTML !== 'jsx') {
+        const style = styleAttributeValue(node);
+        if (style !== null) {
+            return async (textToDoc) => {
+                const declarations = await textToDoc(decodeQuoteEntities(style), {
+                    ...options,
+                    parser: 'css',
+                    __isHTMLStyleAttribute: true,
+                });
+                const value = escapeQuotes(declarations);
+                return ['style="', group$1([indent$1([softline$1, value]), softline$1]), '"'];
+            };
+        }
+    }
     if (node.type !== 'JSXElement')
         return estree.embed(path, options);
     const tag = tagNameOf(node);
@@ -897,7 +1116,7 @@ function embed(path, options) {
     if (tag === 'script') {
         if (isEmpty)
             return estree.embed(path, options);
-        const parser = inferParserByTypeAttribute(attributeStringValue(node, 'type'));
+        const parser = inferScriptParser(node);
         return async (textToDoc, print) => wrapContent(print, await surfacingErrors(textToDoc, source, { ...options, parser }), false);
     }
     if (tag === 'style') {
@@ -922,10 +1141,10 @@ function embed(path, options) {
     return estree.embed(path, options);
 }
 function printVerbatim(source) {
-    return (_textToDoc, print) => group([print('openingElement'), replaceEndOfLine$1(source), print('closingElement')]);
+    return (_textToDoc, print) => group$1([print('openingElement'), replaceEndOfLine$1(source), print('closingElement')]);
 }
 
-const { hardline } = doc.builders;
+const { group, hardline, indent, line, softline } = doc.builders;
 const { replaceEndOfLine } = doc.utils;
 function printDoctype(value) {
     const trimmed = value.trim();
@@ -978,6 +1197,18 @@ function printAttribute(path, options, print) {
         return ['{', print(['value', 'expression']), '}'];
     if (node.astroBacktick)
         return [name, '=', print(['value', 'expression'])];
+    if (options.astroCompressHTML !== 'jsx' &&
+        node.astroSrcsetAttribute &&
+        value?.type === 'Literal' &&
+        typeof value.value === 'string' &&
+        value.value.trim() !== '') {
+        try {
+            return ['srcset="', printSrcset(value.value), '"'];
+        }
+        catch {
+            return ['srcset="', value.value.replaceAll('"', '&quot;'), '"'];
+        }
+    }
     const expression = value?.type === 'JSXExpressionContainer' ? value.expression : null;
     if (options.astroAllowShorthand &&
         expression?.type === 'Identifier' &&
@@ -986,15 +1217,82 @@ function printAttribute(path, options, print) {
     }
     return null;
 }
+function printBreakableOpeningTag(path, options, print) {
+    const node = path.node;
+    const attributes = node.attributes;
+    if (attributes.length !== 1)
+        return null;
+    const value = attributes[0].value;
+    if (value?.type !== 'Literal' || typeof value.value !== 'string')
+        return null;
+    if (value.value.includes('\n'))
+        return null;
+    const end = node.selfClosing
+        ? options.bracketSameLine
+            ? [' />']
+            : [line, '/>']
+        : options.bracketSameLine
+            ? ['>']
+            : [softline, '>'];
+    return group(['<', print('name'), indent([line, print(['attributes', 0])]), ...end]);
+}
+function printWithDanglingBrackets(path, print, lending) {
+    const node = path.node;
+    const children = node.astroChildren;
+    if (!children?.length || !node.closingElement)
+        return null;
+    if (swallowsEdgeWhitespace(node))
+        return null;
+    if (startsWithSpace(children[0]) || endsWithSpace(children.at(-1)))
+        return null;
+    const opening = print('openingElement');
+    if (opening.type !== 'group' || !Array.isArray(opening.contents))
+        return null;
+    const contents = opening.contents.filter((part) => part !== '');
+    if (contents.at(-1) !== '>')
+        return null;
+    const withoutBracket = contents.slice(0, -1);
+    if (withoutBracket.at(-1)?.type === 'line')
+        withoutBracket.pop();
+    const tag = jsxNameOf(node.closingElement.name);
+    if (tag === null)
+        return null;
+    const head = { ...opening, contents: withoutBracket };
+    const shouldBreak = forcesBreak(node);
+    if (isSelfClosing(children.at(-1)) && !children.at(-1).astroIgnored) {
+        const lentBody = print(['children', 0], { mode: 'fill-lending' });
+        return group([head, indent([softline, '>', lentBody]), line, '/>', '</', tag, lending ? '' : '>'], { shouldBreak });
+    }
+    const body = print(['children', 0], { mode: 'fill', suffix: ['</', tag] });
+    return group([head, indent([softline, '>', body]), lending ? '' : [softline, '>']], {
+        shouldBreak,
+    });
+}
+const isSelfClosing = (node) => node.type === 'JSXElement' && !node.closingElement;
+function withoutSelfClosingMarker(printed) {
+    if (Array.isArray(printed)) {
+        return printed.at(-1) === ' />' ? printed.slice(0, -1) : printed;
+    }
+    const tag = printed;
+    if (tag.type !== 'group' || !Array.isArray(tag.contents))
+        return printed;
+    if (tag.contents.at(-1) === ' />')
+        return { ...tag, contents: tag.contents.slice(0, -1) };
+    if (tag.contents.at(-1) !== '/>')
+        return printed;
+    return { ...tag, contents: tag.contents.slice(0, -2) };
+}
+const startsWithSpace = (child) => child.type === 'JSXText' && /^[\t\n\f\r ]/.test(String(child.raw ?? ''));
+const endsWithSpace = (child) => child.type === 'JSXText' && /[\t\n\f\r ]$/.test(String(child.raw ?? ''));
 function unwrapFragmentIndent(printed) {
-    const group = printed;
-    if (group.type !== 'group')
+    const fragment = printed;
+    if (fragment.type !== 'group')
         return printed;
-    if (group.expandedStates) {
-        const states = group.expandedStates.map(unwrapFragmentIndent);
-        return { ...group, contents: states[0], expandedStates: states };
+    if (fragment.expandedStates) {
+        const states = fragment.expandedStates.map(unwrapFragmentIndent);
+        return { ...fragment, contents: states[0], expandedStates: states };
     }
-    const parts = group.contents;
+    const parts = fragment.contents;
     if (!Array.isArray(parts) || parts.length !== 4)
         return printed;
     const indented = parts[1];
@@ -1013,8 +1311,9 @@ const printer = {
     },
     print(path, options, print, args) {
         const node = path.node;
-        if (node[ownChildren])
-            return path.callParent(() => printChildren(path, options, print));
+        if (node[ownChildren]) {
+            return path.callParent(() => printChildren(path, options, print, args ?? {}));
+        }
         if (node[synthetic])
             return '';
         if (node.astroIgnored) {
@@ -1027,6 +1326,25 @@ const printer = {
             if (attribute)
                 return attribute;
         }
+        if (node.type === 'JSXOpeningElement' && options.astroCompressHTML !== 'jsx') {
+            const opening = printBreakableOpeningTag(path, options, print);
+            if (opening)
+                return opening;
+        }
+        if (node.type === 'JSXElement' && args === lends && isSelfClosing(node)) {
+            return withoutSelfClosingMarker(print('openingElement'));
+        }
+        if (node.type === 'JSXElement' && node.astroChildren && !opensRawSubtree(node)) {
+            const dangling = printWithDanglingBrackets(path, print, args === lends);
+            if (dangling)
+                return dangling;
+            const tag = jsxNameOf(node.closingElement.name);
+            return group([
+                print('openingElement'),
+                print(['children', 0], { mode: 'loose' }),
+                args === lends && tag !== null ? ['</', tag] : print('closingElement'),
+            ], { shouldBreak: forcesBreak(node) });
+        }
         if (node.type === 'JSXElement' &&
             node.closingElement &&
             node.children.length > 0 &&