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

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

@@ -1,4 +1,4 @@
-import { ParseResultElement, AnnotationElement, CommentElement, MemberElement, ObjectElement, ArrayElement, isPrimitiveElement, Namespace, SourceMapElement } from '@speclynx/apidom-datamodel';
+import { ParseResultElement, AnnotationElement, CommentElement, MemberElement, ObjectElement, ArrayElement, StringElement, NullElement, isPrimitiveElement, isNullElement, includesClasses, Namespace, SourceMapElement, StyleElement } from '@speclynx/apidom-datamodel';
 import { isComment, isDocument } from "./ast/nodes/predicates.mjs";
 import { YamlStyle, YamlStyleGroup } from "./ast/nodes/YamlStyle.mjs"; // Transform context passed through transformation
 // Node with type property and flat position properties
@@ -125,7 +125,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;
 };
@@ -139,12 +145,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.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;
@@ -238,13 +257,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 (isDocument(child)) break;
-    if (isComment(child)) texts.push(stripCommentHash(child.content));
+    if (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 => !isComment(c));
+      if (rootIndex === -1) break;
+      children.slice(0, rootIndex).filter(isComment).forEach(collect);
+      root = children[rootIndex];
+      children.slice(rootIndex + 1).filter(isComment).forEach(collect);
+    } else if (isComment(child)) {
+      collect(child);
+    }
   }
-  return texts.length > 0 ? texts.join('\n') : null;
+  return comments;
 };
 
 // Stream: Wraps transformed children in ParseResultElement
@@ -269,13 +310,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);
       }
     }
   }
@@ -322,7 +382,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.SinglePair || undefined
     });
     if (comments.outOfScope.length > 0) {
       ctx.promotedComments.push(...comments.outOfScope);
@@ -343,12 +405,34 @@ const transformMapping = (node, ctx) => {
 // KeyValuePair: Transforms to MemberElement
 const transformKeyValuePair = (node, ctx) => {
   const element = new 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 === 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 (isNullElement(keyResult) && includesClasses(keyResult, ['yaml-e-node'])) {
+    const emptyKey = new StringElement('', keyResult.meta, keyResult.attributes);
+    emptyKey.classes.push('yaml-e-key');
+    SourceMapElement.transfer(keyResult, emptyKey);
+    StyleElement.transfer(keyResult, emptyKey);
+    keyResult = emptyKey;
+  }
 
   // @ts-ignore
   element.content.key = keyResult;
@@ -376,10 +460,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.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.Plain && [undefined, '?', '!!null', '!<tag:yaml.org,2002:null>'].includes(tag);
+  const element = isEmptyNode ? new NullElement() : ctx.namespace.toElement(node.content);
+  if (isEmptyNode) {
     element.classes.push('yaml-e-node');
     element.classes.push('yaml-e-scalar');
   }
@@ -390,6 +476,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);
@@ -467,6 +556,7 @@ export const transformYamlAstToApiDOM = (yamlAst, {
     processedDocumentCount: 0,
     indent: 2,
     flowCollectionPadding: null,
+    indentSeq: null,
     promotedComments: []
   };
   const rootNode = yamlAst.rootNode;

package/src/tree-sitter/syntactic-analysis/ast/anchors-aliases/ReferenceManager.cjs

@@ -15,11 +15,27 @@ class ReferenceManager {
     // Anchor registration - currently a no-op as aliases resolve to scalars
   }
   resolveAlias(alias) {
-    return new _YamlScalar.default({
+    const {
+      startLine,
+      startCharacter,
+      startOffset,
+      endLine,
+      endCharacter,
+      endOffset
+    } = alias;
+    const scalar = new _YamlScalar.default({
       content: alias.content,
+      startLine,
+      startCharacter,
+      startOffset,
+      endLine,
+      endCharacter,
+      endOffset,
       style: _YamlStyle.YamlStyle.Plain,
       styleGroup: _YamlStyle.YamlStyleGroup.Flow
     });
+    scalar.alias = alias.content.slice(1);
+    return scalar;
   }
 }
 var _default = exports.default = ReferenceManager;

package/src/tree-sitter/syntactic-analysis/ast/anchors-aliases/ReferenceManager.mjs

@@ -8,11 +8,27 @@ class ReferenceManager {
     // Anchor registration - currently a no-op as aliases resolve to scalars
   }
   resolveAlias(alias) {
-    return new YamlScalar({
+    const {
+      startLine,
+      startCharacter,
+      startOffset,
+      endLine,
+      endCharacter,
+      endOffset
+    } = alias;
+    const scalar = new YamlScalar({
       content: alias.content,
+      startLine,
+      startCharacter,
+      startOffset,
+      endLine,
+      endCharacter,
+      endOffset,
       style: YamlStyle.Plain,
       styleGroup: YamlStyleGroup.Flow
     });
+    scalar.alias = alias.content.slice(1);
+    return scalar;
   }
 }
 export default ReferenceManager;

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlScalar.cjs

@@ -17,6 +17,9 @@ class YamlScalar extends _YamlNode.default {
   static type = 'scalar';
   content;
   rawContent;
+
+  // the name of the alias (without the * indicator) the scalar was resolved from
+  alias;
   constructor({
     content,
     ...rest

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlScalar.mjs

@@ -9,6 +9,9 @@ class YamlScalar extends YamlNode {
   static type = 'scalar';
   content;
   rawContent;
+
+  // the name of the alias (without the * indicator) the scalar was resolved from
+  alias;
   constructor({
     content,
     ...rest

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStream.cjs

@@ -12,6 +12,9 @@ var _predicates = require("./predicates.cjs");
  */
 class YamlStream extends _Node.default {
   static type = 'stream';
+
+  // the line break the stream's first line ends with
+  lineBreak;
 }
 Object.defineProperty(YamlStream.prototype, 'content', {
   get() {

package/src/tree-sitter/syntactic-analysis/ast/nodes/YamlStream.mjs

@@ -5,6 +5,9 @@ import { isDocument, isComment } from "./predicates.mjs";
  */
 class YamlStream extends Node {
   static type = 'stream';
+
+  // the line break the stream's first line ends with
+  lineBreak;
 }
 Object.defineProperty(YamlStream.prototype, 'content', {
   get() {

package/src/tree-sitter/syntactic-analysis/ast/schemas/canonical-format.cjs

@@ -6,15 +6,16 @@ Object.defineProperty(exports, "__esModule", {
 exports.formatFlowSingleQuoted = exports.formatFlowPlain = exports.formatFlowDoubleQuoted = exports.formatBlockLiteral = exports.formatBlockFolded = void 0;
 var _ramda = require("ramda");
 var _ramdaAdjunct = require("ramda-adjunct");
-var _unraw = require("unraw");
 /**
  * Helpers.
  */
 
-const blockStyleRegExp = /^(?<style>[|>])(?<chomping>[+-]?)(?<indentation>[0-9]*)\s/;
+// indentation and chomping indicators may appear in either order (YAML 1.2 §8.1.1)
+const blockStyleRegExp = /^(?<style>[|>])(?<indicators>[+-]?[0-9]?|[0-9][+-])(?:\s|$)/;
 const getIndentationIndicator = content => {
   const matches = content.match(blockStyleRegExp);
-  const indicator = (0, _ramda.pathOr)('', ['groups', 'indentation'], matches);
+  const indicators = (0, _ramda.pathOr)('', ['groups', 'indicators'], matches);
+  const indicator = indicators.replace(/[+-]/, '');
   return (0, _ramdaAdjunct.isEmptyString)(indicator) ? undefined : parseInt(indicator, 10);
 };
 const getIndentation = content => {
@@ -25,30 +26,72 @@ const getIndentation = content => {
     return (0, _ramdaAdjunct.repeatStr)(' ', explicitIndentationIndicator);
   }
 
-  // we assume indentation indicator from first line
-  const firstLine = (0, _ramda.pathOr)('', [1], content.split('\n'));
+  // we assume indentation indicator from first non-empty line (YAML 1.2 §8.1.1.1);
+  // with no non-empty line, the first line is used so that its spaces are still stripped
+  const lines = (0, _ramda.tail)(content.split('\n'));
+  const firstLine = lines.find(line => !/^ *\r?$/.test(line)) ?? (0, _ramda.pathOr)('', [0], lines);
   const implicitIndentationIndicator = (0, _ramda.pathOr)(0, ['groups', 'indentation', 'length'], firstLine.match(/^(?<indentation>[ ]*)/));
   return (0, _ramdaAdjunct.repeatStr)(' ', implicitIndentationIndicator);
 };
+
+// splits a block scalar body into deindented content lines and trailing lines (YAML 1.2 §8.1.1.2):
+// trailing lines are the whitespace-only lines after the last content line, minus any up to and
+// including the last one indented deeper than the block, which are content; without any content
+// line, all lines are trailing
+const splitBlockScalar = (content, chomping) => {
+  const indentation = getIndentation(content).length;
+  const normalized = normalizeLineBreaks(content);
+  const body = normalized.includes('\n') ? normalized.slice(normalized.indexOf('\n') + 1) : '';
+  const lines = body === '' ? [] : body.split('\n');
+  const deindent = line => line.slice(Math.min(indentation, line.search(/[^ ]|$/)));
+
+  // without keep chomping, trailing whitespace-only lines not indented deeper than the first
+  // content line don't belong to the block scalar
+  const firstContent = lines.find(line => /[^ ]/.test(line));
+  if (chomping !== '+' && firstContent !== undefined) {
+    const contentIndentation = firstContent.search(/[^ ]/);
+    while (/^ *$/.test(lines.at(-1)) && lines.at(-1).length <= contentIndentation) lines.pop();
+  }
+  let chompStart = lines.length;
+  while (chompStart > 0 && /^ *$/.test(lines[chompStart - 1])) chompStart -= 1;
+  if (chompStart === 0) return {
+    lines: [],
+    trailing: lines.map(deindent)
+  };
+  for (let i = lines.length - 1; i >= chompStart; i -= 1) {
+    if (lines[i].length > indentation) {
+      chompStart = i + 1;
+      break;
+    }
+  }
+  return {
+    lines: lines.slice(0, chompStart).map(deindent),
+    trailing: lines.slice(chompStart).map(deindent)
+  };
+};
 const getChompingIndicator = content => {
   const matches = content.match(blockStyleRegExp);
-  const indicator = (0, _ramda.pathOr)('', ['groups', 'chomping'], matches);
+  const indicators = (0, _ramda.pathOr)('', ['groups', 'indicators'], matches);
+  const indicator = indicators.replace(/[0-9]/, '');
   return (0, _ramdaAdjunct.isEmptyString)(indicator) ? undefined : indicator;
 };
-const chomp = (indicator, content) => {
-  // clip (single newline at end)
-  if ((0, _ramdaAdjunct.isUndefined)(indicator)) {
-    return `${(0, _ramdaAdjunct.trimEnd)(content)}\n`;
+const chomp = (indicator, value, {
+  lines,
+  trailing
+}) => {
+  // a block without content is empty, unless keep chomping preserves its line breaks
+  if (lines.length === 0) {
+    return indicator === '+' && trailing.length > 0 ? '\n'.repeat(Math.max(1, trailing.length - 1)) : '';
   }
   // strip (no newline at end)
-  if (indicator === '-') {
-    return (0, _ramdaAdjunct.trimEnd)(content);
-  }
-  // keep (all newlines from end)
+  if (indicator === '-') return value;
+  // keep (trailing lines and a newline at end)
   if (indicator === '+') {
-    return content;
+    const kept = value + trailing.map(line => `\n${line}`).join('');
+    return kept.endsWith('\n') ? kept : `${kept}\n`;
   }
-  return content;
+  // clip (single newline at end)
+  return `${value}\n`;
 };
 
 /**
@@ -58,56 +101,108 @@ const chomp = (indicator, content) => {
 // @ts-ignore
 const normalizeLineBreaks = val => val.replace(/\r\n/g, '\n');
 
-// prevent escaped line breaks from being converted to a space
-const preventLineBreakCollapseToSpace = val => val.replace(/\\\n\s*/g, '');
-
-// collapse line breaks into spaces
-const collapseLineBreakToSpace = val => {
-  /**
-   * Safari doesn't support negative lookbehind, thus we use mimicking technique:
-   *
-   * - https://blog.stevenlevithan.com/archives/mimic-lookbehind-javascript
-   *
-   * Ideally we want to use following replace, but that's not currently possible:
-   *
-   * .replace(/[^\n]\n([^\n]+)/g, (match: string, p1: string) => ` ${p1.trimLeft()}`)
-   */
-  return val.replace(/(\n)?\n([^\n]+)/g, (match, p1, p2) => p1 ? match : ` ${p2.trimStart()}`).replace(/[\n]{2}/g, '\n');
+// folds the line breaks of a flow scalar (YAML 1.2 §6.5, §7.3):
+// white space around a line break is dropped, a single line break becomes a space and every
+// further one a line break; with escapes (double-quoted style), escape sequences are left for
+// unescaping and an escaped line break is dropped together with the next line's indentation
+const foldFlowLines = (0, _ramda.curry)((escapes, text) => text.replace(
+// a white space run not followed by a line break is consumed whole, which keeps the search
+// linear instead of rescanning the run from every position in it
+escapes ? /\\(?:\n[ \t]*|[^])|[ \t]*\n(?:[ \t]*\n)*[ \t]*|[ \t]+/g : /[ \t]*\n(?:[ \t]*\n)*[ \t]*|[ \t]+/g, match => {
+  if (match.startsWith('\\')) return match[1] === '\n' ? '' : match;
+  if (!match.includes('\n')) return match;
+  const lineBreaks = match.split('\n').length - 1;
+  return lineBreaks === 1 ? ' ' : '\n'.repeat(lineBreaks - 1);
+}));
+
+// folds the line break between two lines into a space; empty lines between them stay as line
+// breaks, and a line break next to a more-indented line isn't folded (YAML 1.2 §6.5)
+const foldLines = text => {
+  const parts = text.split(/\n(\n*)/); // lines alternating with the empty lines between them
+  let folded = parts[0];
+  for (let i = 1; i < parts.length; i += 2) {
+    const moreIndented = /^[ \t]/.test(parts[i - 1]) || /^[ \t]/.test(parts[i + 1]);
+    folded += (moreIndented ? `\n${parts[i]}` : parts[i] || ' ') + parts[i + 1];
+  }
+  return folded;
+};
+
+// escaped characters of YAML 1.2 §5.7, productions [42] to [58]
+const escapedCharacters = {
+  '0': '\u0000',
+  // null
+  a: '\u0007',
+  // bell
+  b: '\u0008',
+  // backspace
+  t: '\u0009',
+  // horizontal tab
+  '\t': '\u0009',
+  // horizontal tab
+  n: '\u000a',
+  // line feed
+  v: '\u000b',
+  // vertical tab
+  f: '\u000c',
+  // form feed
+  r: '\u000d',
+  // carriage return
+  e: '\u001b',
+  // escape
+  ' ': '\u0020',
+  // space
+  '"': '\u0022',
+  // double quote
+  '/': '\u002f',
+  // slash
+  '\\': '\u005c',
+  // backslash
+  N: '\u0085',
+  // next line
+  _: '\u00a0',
+  // non-breaking space
+  L: '\u2028',
+  // line separator
+  P: '\u2029' // paragraph separator
 };
+
+// unescapes the escape sequences of a double-quoted scalar (YAML 1.2 §5.7); an escape sequence
+// outside of the spec is kept as-is
+const unescapeDoubleQuoted = text => text.replace(/\\(?:x([0-9a-fA-F]{2})|u([0-9a-fA-F]{4})|U([0-9a-fA-F]{8})|([^]))/g, (match, x, u, U, char) => {
+  const hex = x ?? u ?? U;
+  if (hex === undefined) return escapedCharacters[char] ?? match;
+  const codePoint = parseInt(hex, 16);
+  return codePoint <= 0x10ffff ? String.fromCodePoint(codePoint) : match;
+});
 const removeQuotes = (0, _ramda.curry)((quoteType, val) => val.replace(new RegExp(`^${quoteType}`), '').replace(new RegExp(`${quoteType}$`), ''));
 
 /**
  * Formats Flow Scalar Plain style.
  * https://yaml.org/spec/1.2/spec.html#id2788859
  */
-const formatFlowPlain = exports.formatFlowPlain = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, collapseLineBreakToSpace, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'));
+const formatFlowPlain = exports.formatFlowPlain = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, foldFlowLines(false));
 
 /**
  * Formats Flow Scalar Single-Quoted style.
  * https://yaml.org/spec/1.2/spec.html#id2788097
  */
 
-const formatFlowSingleQuoted = exports.formatFlowSingleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, collapseLineBreakToSpace, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'), removeQuotes("'"));
+const formatFlowSingleQuoted = exports.formatFlowSingleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, foldFlowLines(false), removeQuotes("'"), (0, _ramda.replace)(/''/g, "'"));
 
 /**
  * Formats Flow Scalar Double-Quoted style.
  * https://yaml.org/spec/1.2/spec.html#id2787109
  */
-const formatFlowDoubleQuoted = exports.formatFlowDoubleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, preventLineBreakCollapseToSpace, collapseLineBreakToSpace, _unraw.unraw, (0, _ramda.split)('\n'), (0, _ramda.map)(_ramdaAdjunct.trimStart), (0, _ramda.join)('\n'), removeQuotes('"'));
+const formatFlowDoubleQuoted = exports.formatFlowDoubleQuoted = (0, _ramda.pipe)(normalizeLineBreaks, _ramda.trim, foldFlowLines(true), unescapeDoubleQuoted, removeQuotes('"'));
 
 /**
  * Formats Block Scalar Literal style.
  * https://yaml.org/spec/1.2/spec.html#id2795688
  */
 const formatBlockLiteral = content => {
-  const indentation = getIndentation(content);
-  const chompingIndicator = getChompingIndicator(content);
-  const normalized = normalizeLineBreaks(content);
-  const lines = (0, _ramda.tail)(normalized.split('\n')); // first line only contains indicators
-  const transducer = (0, _ramda.compose)((0, _ramda.map)((0, _ramdaAdjunct.trimCharsStart)(indentation)), (0, _ramda.map)((0, _ramdaAdjunct.concatRight)('\n')));
-  // @ts-ignore
-  const deindented = (0, _ramda.transduce)(transducer, _ramda.concat, '', lines);
-  return chomp(chompingIndicator, deindented);
+  const chomping = getChompingIndicator(content);
+  const split = splitBlockScalar(content, chomping);
+  return chomp(chomping, split.lines.join('\n'), split);
 };
 
 /**
@@ -116,14 +211,12 @@ const formatBlockLiteral = content => {
  */
 exports.formatBlockLiteral = formatBlockLiteral;
 const formatBlockFolded = content => {
-  const indentation = getIndentation(content);
-  const chompingIndicator = getChompingIndicator(content);
-  const normalized = normalizeLineBreaks(content);
-  const lines = (0, _ramda.tail)(normalized.split('\n')); // first line only contains indicators
-  const transducer = (0, _ramda.compose)((0, _ramda.map)((0, _ramdaAdjunct.trimCharsStart)(indentation)), (0, _ramda.map)((0, _ramdaAdjunct.concatRight)('\n')));
-  // @ts-ignore
-  const deindented = (0, _ramda.transduce)(transducer, _ramda.concat, '', lines);
-  const collapsed = collapseLineBreakToSpace(deindented);
-  return chomp(chompingIndicator, collapsed);
+  const chomping = getChompingIndicator(content);
+  const split = splitBlockScalar(content, chomping);
+  // leading line breaks are preserved as-is; folding applies only between content lines
+  const text = split.lines.join('\n');
+  const leadingLineBreaks = text.match(/^\n*/)[0];
+  const folded = leadingLineBreaks + foldLines(text.slice(leadingLineBreaks.length));
+  return chomp(chomping, folded, split);
 };
 exports.formatBlockFolded = formatBlockFolded;