@speclynx/apidom-parser-adapter-yaml-1-2 6.0.6 → 6.1.1

package/src/tree-sitter/syntactic-analysis/CstTransformer.cjs

@@ -22,6 +22,7 @@ var _YamlSequence = _interopRequireDefault(require("./ast/nodes/YamlSequence.cjs
 var _YamlStream = _interopRequireDefault(require("./ast/nodes/YamlStream.cjs"));
 var _YamlTag = _interopRequireWildcard(require("./ast/nodes/YamlTag.cjs"));
 var _YamlStyle = require("./ast/nodes/YamlStyle.cjs");
+var _predicates = require("./ast/nodes/predicates.cjs");
 const getCursorInfo = cursor => ({
   type: cursor.nodeType,
   startPosition: cursor.startPosition,
@@ -35,6 +36,15 @@ const getCursorInfo = cursor => ({
   fieldName: cursor.currentFieldName
 });
 
+// TreeCursor#copy() in web-tree-sitter 0.27.1 doesn't marshal the cursor it's called on, so it
+// copies whichever cursor or node was marshalled last; resetTo() marshals both cursors
+// https://github.com/tree-sitter/tree-sitter/issues/6045
+const copyCursor = cursor => {
+  const copy = cursor.currentNode.tree.walk();
+  copy.resetTo(cursor);
+  return copy;
+};
+
 // Flat position properties extracted from CursorInfo
 
 const toPositionProps = info => ({
@@ -242,6 +252,8 @@ const createTransformers = transformerMap => ({
       ...toPositionProps(info),
       isMissing: info.isMissing
     });
+    const lineBreak = info.text.match(/\r?\n/);
+    if (lineBreak) stream.lineBreak = lineBreak[0];
     return new _ParseResult.default({
       children: [stream]
     });
@@ -325,14 +337,18 @@ const createTransformers = transformerMap => ({
     return children;
   },
   flow_node(cursor, ctx, siblings) {
-    // Check if there's a kind node (scalar, mapping, or sequence)
+    // Check if there's a kind node (scalar, mapping, sequence or alias)
     let hasKindNode = false;
     let lastChildInfo = null;
+    let tagInfo;
+    let anchorInfo;
     if (cursor.gotoFirstChild()) {
       do {
         const childInfo = getCursorInfo(cursor);
         lastChildInfo = childInfo;
-        if (childInfo.type.endsWith('scalar') || childInfo.type.endsWith('mapping') || childInfo.type.endsWith('sequence')) {
+        if (childInfo.type === 'tag') tagInfo = childInfo;
+        if (childInfo.type === 'anchor') anchorInfo = childInfo;
+        if (childInfo.type.endsWith('scalar') || childInfo.type.endsWith('mapping') || childInfo.type.endsWith('sequence') || childInfo.type === 'alias') {
           hasKindNode = true;
         }
       } while (cursor.gotoNextSibling());
@@ -345,10 +361,15 @@ const createTransformers = transformerMap => ({
 
     // No kind node - create empty scalar
     if (lastChildInfo) {
+      const emptyAnchorInfo = anchorInfo ?? siblings.anchor;
       const emptyScalarNode = new _YamlScalar.default({
         content: '',
-        anchor: siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined,
-        tag: toYamlTag(lastChildInfo, siblings.tag),
+        // the anchor and tag of an empty node are children of the flow node, not siblings
+        anchor: emptyAnchorInfo ? toYamlAnchor(emptyAnchorInfo) : undefined,
+        tag: toYamlTag({
+          ...lastChildInfo,
+          type: 'plain_scalar'
+        }, tagInfo ?? siblings.tag),
         startLine: lastChildInfo.endPosition.row,
         startCharacter: lastChildInfo.endPosition.column,
         startOffset: lastChildInfo.endIndex,
@@ -447,8 +468,39 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const children = processChildren(cursor, ctx, transformerMap);
+
+    // an entry with only a key (e.g. { a }) has an empty value (YAML 1.2 §7.4.2); the CST has no
+    // flow_pair for it, so the pair is made here
+    const toPair = child => {
+      if (!(0, _predicates.isScalar)(child) && !(0, _predicates.isMapping)(child) && !(0, _predicates.isSequence)(child)) return child;
+      const emptyValue = new _YamlScalar.default({
+        content: '',
+        startLine: child.endLine,
+        startCharacter: child.endCharacter,
+        startOffset: child.endOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        tag: new _YamlTag.default({
+          explicitName: '?',
+          kind: _YamlTag.YamlNodeKind.Scalar
+        }),
+        styleGroup: _YamlStyle.YamlStyleGroup.Flow,
+        style: _YamlStyle.YamlStyle.Plain
+      });
+      return new _YamlKeyValuePair.default({
+        children: [child, emptyValue],
+        startLine: child.startLine,
+        startCharacter: child.startCharacter,
+        startOffset: child.startOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        styleGroup: _YamlStyle.YamlStyleGroup.Flow
+      });
+    };
     const mappingNode = new _YamlMapping.default({
-      children: children.flat().filter(c => c !== null),
+      children: children.flat().filter(c => c !== null).map(toPair),
       ...toPositionProps(info),
       anchor,
       tag,
@@ -567,8 +619,30 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const children = processChildren(cursor, ctx, transformerMap);
+
+    // a single pair as a flow sequence entry (e.g. [a: 1]) is a mapping with that one pair
+    // (YAML 1.2 §7.4.1); the CST has the flow_pair directly in the flow_sequence
+    const toSinglePairMapping = child => {
+      if (!(0, _predicates.isKeyValuePair)(child)) return child;
+      const mappingNode = new _YamlMapping.default({
+        children: [child],
+        startLine: child.startLine,
+        startCharacter: child.startCharacter,
+        startOffset: child.startOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        tag: new _YamlTag.default({
+          explicitName: '!',
+          kind: _YamlTag.YamlNodeKind.Mapping
+        }),
+        styleGroup: _YamlStyle.YamlStyleGroup.Flow,
+        style: _YamlStyle.YamlStyle.SinglePair
+      });
+      return ctx.schema.resolve(mappingNode);
+    };
     const sequenceNode = new _YamlSequence.default({
-      children: children.flat().filter(c => c !== null),
+      children: children.flat().filter(c => c !== null).map(toSinglePairMapping),
       ...toPositionProps(info),
       anchor,
       tag,
@@ -631,15 +705,44 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const style = info.text.startsWith('|') ? _YamlStyle.YamlStyle.Literal : info.text.startsWith('>') ? _YamlStyle.YamlStyle.Folded : _YamlStyle.YamlStyle.Plain;
+
+    // trailing lines belong to the block scalar, but the CST node ends at its last content
+    // character when another node follows; the lines up to the line of the next node in
+    // source order are taken from the text of the node holding both
+    let trailingLines = '';
+    if (!info.text.endsWith('\n')) {
+      // a cursor copy walks up in constant time per step, unlike Node#parent
+      const following = copyCursor(cursor);
+      let hasNext = following.gotoNextSibling();
+      while (!hasNext && following.gotoParent()) {
+        hasNext = following.gotoNextSibling();
+      }
+      // without a next node the scalar ends the input, so there are no lines to add
+      if (hasNext) {
+        const nextIndex = following.startIndex;
+        following.gotoParent();
+        const gap = following.nodeText.slice(info.endIndex - following.startIndex, nextIndex - following.startIndex);
+        trailingLines = gap.slice(0, gap.lastIndexOf('\n') + 1);
+      }
+      following.delete();
+    }
+
+    // an explicit indentation indicator is relative to the parent node's indentation: the
+    // column of the mapping pair or sequence item holding the block node (0 at top level);
+    // content lines are rebased to it so that the indicator can be applied to them as is
+    const holder = cursor.currentNode.parent?.parent;
+    const parentIndentation = holder?.type === 'block_mapping_pair' || holder?.type === 'block_sequence_item' ? holder.startPosition.column : 0;
+    const rebased = (info.text + trailingLines).replace(new RegExp(`\n {0,${parentIndentation}}`, 'g'), '\n');
     const scalarNode = new _YamlScalar.default({
-      content: info.text,
+      content: rebased,
       anchor,
       tag,
       ...toPositionProps(info),
       styleGroup: _YamlStyle.YamlStyleGroup.Block,
       style
     });
-    scalarNode.rawContent = info.text;
+    // the block's source text, rebased to its parent's indentation and with its trailing lines
+    scalarNode.rawContent = rebased;
     registerAnchor(scalarNode, ctx);
     return ctx.schema.resolve(scalarNode);
   },
@@ -653,7 +756,8 @@ const createTransformers = transformerMap => ({
   alias(cursor, ctx) {
     const info = getCursorInfo(cursor);
     const alias = new _YamlAlias.default({
-      content: info.text
+      content: info.text,
+      ...toPositionProps(info)
     });
     return ctx.referenceManager.resolveAlias(alias);
   },

package/src/tree-sitter/syntactic-analysis/CstTransformer.mjs

@@ -14,6 +14,7 @@ import YamlSequence from "./ast/nodes/YamlSequence.mjs";
 import YamlStream from "./ast/nodes/YamlStream.mjs";
 import YamlTag, { YamlNodeKind } from "./ast/nodes/YamlTag.mjs";
 import { YamlStyle, YamlStyleGroup } from "./ast/nodes/YamlStyle.mjs";
+import { isKeyValuePair, isMapping, isScalar, isSequence } from "./ast/nodes/predicates.mjs";
 const getCursorInfo = cursor => ({
   type: cursor.nodeType,
   startPosition: cursor.startPosition,
@@ -27,6 +28,15 @@ const getCursorInfo = cursor => ({
   fieldName: cursor.currentFieldName
 });
 
+// TreeCursor#copy() in web-tree-sitter 0.27.1 doesn't marshal the cursor it's called on, so it
+// copies whichever cursor or node was marshalled last; resetTo() marshals both cursors
+// https://github.com/tree-sitter/tree-sitter/issues/6045
+const copyCursor = cursor => {
+  const copy = cursor.currentNode.tree.walk();
+  copy.resetTo(cursor);
+  return copy;
+};
+
 // Flat position properties extracted from CursorInfo
 
 const toPositionProps = info => ({
@@ -234,6 +244,8 @@ const createTransformers = transformerMap => ({
       ...toPositionProps(info),
       isMissing: info.isMissing
     });
+    const lineBreak = info.text.match(/\r?\n/);
+    if (lineBreak) stream.lineBreak = lineBreak[0];
     return new ParseResult({
       children: [stream]
     });
@@ -317,14 +329,18 @@ const createTransformers = transformerMap => ({
     return children;
   },
   flow_node(cursor, ctx, siblings) {
-    // Check if there's a kind node (scalar, mapping, or sequence)
+    // Check if there's a kind node (scalar, mapping, sequence or alias)
     let hasKindNode = false;
     let lastChildInfo = null;
+    let tagInfo;
+    let anchorInfo;
     if (cursor.gotoFirstChild()) {
       do {
         const childInfo = getCursorInfo(cursor);
         lastChildInfo = childInfo;
-        if (childInfo.type.endsWith('scalar') || childInfo.type.endsWith('mapping') || childInfo.type.endsWith('sequence')) {
+        if (childInfo.type === 'tag') tagInfo = childInfo;
+        if (childInfo.type === 'anchor') anchorInfo = childInfo;
+        if (childInfo.type.endsWith('scalar') || childInfo.type.endsWith('mapping') || childInfo.type.endsWith('sequence') || childInfo.type === 'alias') {
           hasKindNode = true;
         }
       } while (cursor.gotoNextSibling());
@@ -337,10 +353,15 @@ const createTransformers = transformerMap => ({
 
     // No kind node - create empty scalar
     if (lastChildInfo) {
+      const emptyAnchorInfo = anchorInfo ?? siblings.anchor;
       const emptyScalarNode = new YamlScalar({
         content: '',
-        anchor: siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined,
-        tag: toYamlTag(lastChildInfo, siblings.tag),
+        // the anchor and tag of an empty node are children of the flow node, not siblings
+        anchor: emptyAnchorInfo ? toYamlAnchor(emptyAnchorInfo) : undefined,
+        tag: toYamlTag({
+          ...lastChildInfo,
+          type: 'plain_scalar'
+        }, tagInfo ?? siblings.tag),
         startLine: lastChildInfo.endPosition.row,
         startCharacter: lastChildInfo.endPosition.column,
         startOffset: lastChildInfo.endIndex,
@@ -439,8 +460,39 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const children = processChildren(cursor, ctx, transformerMap);
+
+    // an entry with only a key (e.g. { a }) has an empty value (YAML 1.2 §7.4.2); the CST has no
+    // flow_pair for it, so the pair is made here
+    const toPair = child => {
+      if (!isScalar(child) && !isMapping(child) && !isSequence(child)) return child;
+      const emptyValue = new YamlScalar({
+        content: '',
+        startLine: child.endLine,
+        startCharacter: child.endCharacter,
+        startOffset: child.endOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        tag: new YamlTag({
+          explicitName: '?',
+          kind: YamlNodeKind.Scalar
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.Plain
+      });
+      return new YamlKeyValuePair({
+        children: [child, emptyValue],
+        startLine: child.startLine,
+        startCharacter: child.startCharacter,
+        startOffset: child.startOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        styleGroup: YamlStyleGroup.Flow
+      });
+    };
     const mappingNode = new YamlMapping({
-      children: children.flat().filter(c => c !== null),
+      children: children.flat().filter(c => c !== null).map(toPair),
       ...toPositionProps(info),
       anchor,
       tag,
@@ -559,8 +611,30 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const children = processChildren(cursor, ctx, transformerMap);
+
+    // a single pair as a flow sequence entry (e.g. [a: 1]) is a mapping with that one pair
+    // (YAML 1.2 §7.4.1); the CST has the flow_pair directly in the flow_sequence
+    const toSinglePairMapping = child => {
+      if (!isKeyValuePair(child)) return child;
+      const mappingNode = new YamlMapping({
+        children: [child],
+        startLine: child.startLine,
+        startCharacter: child.startCharacter,
+        startOffset: child.startOffset,
+        endLine: child.endLine,
+        endCharacter: child.endCharacter,
+        endOffset: child.endOffset,
+        tag: new YamlTag({
+          explicitName: '!',
+          kind: YamlNodeKind.Mapping
+        }),
+        styleGroup: YamlStyleGroup.Flow,
+        style: YamlStyle.SinglePair
+      });
+      return ctx.schema.resolve(mappingNode);
+    };
     const sequenceNode = new YamlSequence({
-      children: children.flat().filter(c => c !== null),
+      children: children.flat().filter(c => c !== null).map(toSinglePairMapping),
       ...toPositionProps(info),
       anchor,
       tag,
@@ -623,15 +697,44 @@ const createTransformers = transformerMap => ({
     const tag = toYamlTag(info, siblings.tag);
     const anchor = siblings.anchor ? toYamlAnchor(siblings.anchor) : undefined;
     const style = info.text.startsWith('|') ? YamlStyle.Literal : info.text.startsWith('>') ? YamlStyle.Folded : YamlStyle.Plain;
+
+    // trailing lines belong to the block scalar, but the CST node ends at its last content
+    // character when another node follows; the lines up to the line of the next node in
+    // source order are taken from the text of the node holding both
+    let trailingLines = '';
+    if (!info.text.endsWith('\n')) {
+      // a cursor copy walks up in constant time per step, unlike Node#parent
+      const following = copyCursor(cursor);
+      let hasNext = following.gotoNextSibling();
+      while (!hasNext && following.gotoParent()) {
+        hasNext = following.gotoNextSibling();
+      }
+      // without a next node the scalar ends the input, so there are no lines to add
+      if (hasNext) {
+        const nextIndex = following.startIndex;
+        following.gotoParent();
+        const gap = following.nodeText.slice(info.endIndex - following.startIndex, nextIndex - following.startIndex);
+        trailingLines = gap.slice(0, gap.lastIndexOf('\n') + 1);
+      }
+      following.delete();
+    }
+
+    // an explicit indentation indicator is relative to the parent node's indentation: the
+    // column of the mapping pair or sequence item holding the block node (0 at top level);
+    // content lines are rebased to it so that the indicator can be applied to them as is
+    const holder = cursor.currentNode.parent?.parent;
+    const parentIndentation = holder?.type === 'block_mapping_pair' || holder?.type === 'block_sequence_item' ? holder.startPosition.column : 0;
+    const rebased = (info.text + trailingLines).replace(new RegExp(`\n {0,${parentIndentation}}`, 'g'), '\n');
     const scalarNode = new YamlScalar({
-      content: info.text,
+      content: rebased,
       anchor,
       tag,
       ...toPositionProps(info),
       styleGroup: YamlStyleGroup.Block,
       style
     });
-    scalarNode.rawContent = info.text;
+    // the block's source text, rebased to its parent's indentation and with its trailing lines
+    scalarNode.rawContent = rebased;
     registerAnchor(scalarNode, ctx);
     return ctx.schema.resolve(scalarNode);
   },
@@ -645,7 +748,8 @@ const createTransformers = transformerMap => ({
   alias(cursor, ctx) {
     const info = getCursorInfo(cursor);
     const alias = new YamlAlias({
-      content: info.text
+      content: info.text,
+      ...toPositionProps(info)
     });
     return ctx.referenceManager.resolveAlias(alias);
   },

package/src/tree-sitter/syntactic-analysis/YamlAstTransformer.cjs

@@ -134,7 +134,13 @@ const applyComments = (elements, comments) => {
 const detectFlowPadding = node => {
   const firstChild = (node.children || [])[0];
   if (firstChild && typeof node.startCharacter === 'number' && typeof firstChild.startCharacter === 'number') {
-    return firstChild.startCharacter - node.startCharacter > 1;
+    // a sequence item starts with its tag or anchor, which aren't part of its node's position
+    const {
+      tag,
+      anchor
+    } = firstChild;
+    const firstStart = Math.min(firstChild.startCharacter, tag?.startCharacter ?? Infinity, anchor?.startCharacter ?? Infinity);
+    return firstStart - node.startCharacter > 1;
   }
   return true;
 };
@@ -148,12 +154,25 @@ const buildYamlStyle = (node, ctx, extras) => {
   if (ctx.flowCollectionPadding !== null) {
     yamlStyle.flowCollectionPadding = ctx.flowCollectionPadding;
   }
+  if (ctx.indentSeq !== null) {
+    yamlStyle.indentSeq = ctx.indentSeq;
+  }
   if (node.comment) {
     yamlStyle.comment = node.comment;
   }
   if (node.commentBefore) {
     yamlStyle.commentBefore = node.commentBefore;
   }
+  // an untagged node has the non-specific tag '?' when it's a plain scalar and '!' otherwise
+  // (YAML 1.2 §6.9.1); an explicit '!' on any other node means the same as no tag
+  const tag = node.tag?.explicitName;
+  if (tag !== undefined && tag !== (node.style === _YamlStyle.YamlStyle.Plain ? '?' : '!')) {
+    yamlStyle.tag = tag;
+  }
+  // the anchor's name, without the & indicator
+  if (node.anchor) {
+    yamlStyle.anchor = node.anchor.name.slice(1);
+  }
   if (extras) {
     for (const [key, value] of Object.entries(extras)) {
       if (value !== undefined) yamlStyle[key] = value;
@@ -247,13 +266,35 @@ const transformChildren = (children, ctx) => {
 
 // stream comments that precede the first document, joined; null when there are none
 // (stream children are in source order, so everything before the document node qualifies)
-const collectPreDocumentComments = node => {
-  const texts = [];
+// stream comments around the first document: before it, on its last line and on the lines after it,
+// up to the next document
+const collectStreamComments = node => {
+  const comments = {
+    before: [],
+    inline: [],
+    after: []
+  };
+  let root;
+  const collect = comment => {
+    const text = stripCommentHash(comment.content);
+    if (!root) comments.before.push(text);else if (comment.startLine === root.endLine) comments.inline.push(text);else comments.after.push(text);
+  };
   for (const child of node.children) {
-    if ((0, _predicates.isDocument)(child)) break;
-    if ((0, _predicates.isComment)(child)) texts.push(stripCommentHash(child.content));
+    if ((0, _predicates.isDocument)(child)) {
+      if (root) break;
+      // comments after an explicit document start (---) or before an explicit document end (...)
+      // are the document's own children, around its root node
+      const children = child.children || [];
+      const rootIndex = children.findIndex(c => !(0, _predicates.isComment)(c));
+      if (rootIndex === -1) break;
+      children.slice(0, rootIndex).filter(_predicates.isComment).forEach(collect);
+      root = children[rootIndex];
+      children.slice(rootIndex + 1).filter(_predicates.isComment).forEach(collect);
+    } else if ((0, _predicates.isComment)(child)) {
+      collect(child);
+    }
   }
-  return texts.length > 0 ? texts.join('\n') : null;
+  return comments;
 };
 
 // Stream: Wraps transformed children in ParseResultElement
@@ -278,13 +319,32 @@ const transformStream = (node, ctx) => {
     const resultElement = elements[0];
     resultElement.classes.push('result');
 
-    // stream comments before the first document belong above the result element;
-    // capture them as commentBefore so style round-trips can re-emit them
+    // stream comments before the first document belong above the result element, ones on its last
+    // line to it and ones on later lines to the document; capture them so style round-trips can
+    // re-emit them
     if (ctx.style) {
-      const preDocumentComments = collectPreDocumentComments(node);
-      if (preDocumentComments !== null) {
+      const {
+        before,
+        inline,
+        after
+      } = collectStreamComments(node);
+      if (before.length > 0) {
         const existing = getYamlStyleProp(resultElement, 'commentBefore');
-        setYamlStyleProp(resultElement, 'commentBefore', typeof existing === 'string' ? `${preDocumentComments}\n${existing}` : preDocumentComments);
+        const text = before.join('\n');
+        setYamlStyleProp(resultElement, 'commentBefore', typeof existing === 'string' ? `${text}\n${existing}` : text);
+      }
+      if (inline.length > 0 && typeof getYamlStyleProp(resultElement, 'comment') !== 'string') {
+        setYamlStyleProp(resultElement, 'comment', inline.join('\n'));
+      }
+      // comments promoted out of the root's last nested collection have no next sibling to precede
+      // and end the root, so they come before the stream comments after it
+      after.unshift(...ctx.promotedComments);
+      if (after.length > 0) {
+        setYamlStyleProp(resultElement, 'documentComment', after.join('\n'));
+      }
+      // line breaks other than LF, which the YAML library writes
+      if (node.lineBreak === '\r\n') {
+        setYamlStyleProp(resultElement, 'lineBreak', node.lineBreak);
       }
     }
   }
@@ -331,7 +391,9 @@ const transformCollection = (element, node, ctx) => {
     element._content = childElements; // eslint-disable-line @typescript-eslint/no-explicit-any
     applyComments(childElements, comments);
     element.style = buildYamlStyle(node, ctx, {
-      comment: comments.trailing
+      comment: comments.trailing,
+      // a single pair written directly in a flow sequence (e.g. [a: 1])
+      singlePair: node.style === _YamlStyle.YamlStyle.SinglePair || undefined
     });
     if (comments.outOfScope.length > 0) {
       ctx.promotedComments.push(...comments.outOfScope);
@@ -352,12 +414,34 @@ const transformMapping = (node, ctx) => {
 // KeyValuePair: Transforms to MemberElement
 const transformKeyValuePair = (node, ctx) => {
   const element = new _apidomDatamodel.MemberElement();
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const {
+    key,
+    value
+  } = node;
+  if (ctx.style && ctx.indentSeq === null && value?.type === 'sequence') {
+    const {
+      styleGroup,
+      startCharacter
+    } = value;
+    if (styleGroup === _YamlStyle.YamlStyleGroup.Block) {
+      ctx.indentSeq = startCharacter > node.startCharacter;
+    }
+  }
 
   // Transform key and value (these are dynamically defined properties)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const keyResult = transform(node.key, ctx);
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  const valueResult = transform(node.value, ctx);
+  let keyResult = transform(key, ctx);
+  const valueResult = transform(value, ctx);
+
+  // an empty key is a null in YAML, but a JavaScript property name can't be null, so it's the empty
+  // string it's named by, marked as an empty key
+  if ((0, _apidomDatamodel.isNullElement)(keyResult) && (0, _apidomDatamodel.includesClasses)(keyResult, ['yaml-e-node'])) {
+    const emptyKey = new _apidomDatamodel.StringElement('', keyResult.meta, keyResult.attributes);
+    emptyKey.classes.push('yaml-e-key');
+    _apidomDatamodel.SourceMapElement.transfer(keyResult, emptyKey);
+    _apidomDatamodel.StyleElement.transfer(keyResult, emptyKey);
+    keyResult = emptyKey;
+  }
 
   // @ts-ignore
   element.content.key = keyResult;
@@ -385,10 +469,12 @@ const transformSequence = (node, ctx) => {
 
 // Scalar: Converts to Element via namespace
 const transformScalar = (node, ctx) => {
-  const element = ctx.namespace.toElement(node.content);
-
-  // Translate style information about empty nodes
-  if (node.content === '' && node.style === _YamlStyle.YamlStyle.Plain) {
+  // an empty node (YAML 1.2 §7.2) is a null unless a tag other than the null tag makes it
+  // something else (e.g. !!str makes it an empty string); its classes tell it from an explicit null
+  const tag = node.tag?.explicitName;
+  const isEmptyNode = node.content === '' && node.style === _YamlStyle.YamlStyle.Plain && [undefined, '?', '!!null', '!<tag:yaml.org,2002:null>'].includes(tag);
+  const element = isEmptyNode ? new _apidomDatamodel.NullElement() : ctx.namespace.toElement(node.content);
+  if (isEmptyNode) {
     element.classes.push('yaml-e-node');
     element.classes.push('yaml-e-scalar');
   }
@@ -399,6 +485,9 @@ const transformScalar = (node, ctx) => {
     if (node.rawContent !== undefined) {
       extras.rawContent = node.rawContent;
     }
+    if (node.alias !== undefined) {
+      extras.alias = node.alias;
+    }
     element.style = buildYamlStyle(node, ctx, extras);
   }
   maybeAddSourceMap(node, element, ctx);
@@ -476,6 +565,7 @@ const transformYamlAstToApiDOM = (yamlAst, {
     processedDocumentCount: 0,
     indent: 2,
     flowCollectionPadding: null,
+    indentSeq: null,
     promotedComments: []
   };
   const rootNode = yamlAst.rootNode;