pkgs/yaml_edit/lib/src/utils.dart - tools - Git at Google

 // Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.

 import 'dart:math';

 import 'package:source_span/source_span.dart';
 import 'package:yaml/yaml.dart';

 import 'editor.dart';
 import 'source_edit.dart';
 import 'wrap.dart';

 /// Invoke [fn] while setting [yamlWarningCallback] to [warn], and restore
 /// [YamlWarningCallback] after [fn] returns.
 ///
 /// Defaults to a [warn] function that ignores all warnings.
 T withYamlWarningCallback<T>(
   T Function() fn, {
   YamlWarningCallback warn = _ignoreWarning,
 }) {
   final original = yamlWarningCallback;
   try {
     yamlWarningCallback = warn;
     return fn();
   } finally {
     yamlWarningCallback = original;
   }
 }

 void _ignoreWarning(String warning, [SourceSpan? span]) {/* ignore warning */}

 /// Determines if [string] is dangerous by checking if parsing the plain string
 /// can return a result different from [string].
 ///
 /// This function is also capable of detecting if non-printable characters are
 /// in [string].
 bool isDangerousString(String string) {
   try {
     final node = withYamlWarningCallback(() => loadYamlNode(string));
     if (node.value != string) {
       return true;
     }

     // [string] should also not contain the `[`, `]`, `,`, `{` and `}` indicator
     // characters.
     return string.contains(RegExp(r'\{|\[|\]|\}|,'));
   } catch (e) {
     /// This catch statement catches [ArgumentError] in `loadYamlNode` when
     /// a string can be interpreted as a URI tag, but catches for other
     /// [YamlException]s
     return true;
   }
 }

 /// Asserts that [value] is a valid scalar according to YAML.
 ///
 /// A valid scalar is a number, String, boolean, or null.
 void assertValidScalar(Object? value) {
   if (value is num || value is String || value is bool || value == null) {
     return;
   }

   throw ArgumentError.value(value, 'value', 'Not a valid scalar type!');
 }

 /// Checks if [node] is a [YamlNode] with block styling.
 ///
 /// [ScalarStyle.ANY] and [CollectionStyle.ANY] are considered to be block
 /// styling by default for maximum flexibility.
 bool isBlockNode(YamlNode node) {
   if (node is YamlScalar) {
     if (node.style == ScalarStyle.LITERAL ||
         node.style == ScalarStyle.FOLDED ||
         node.style == ScalarStyle.ANY) {
       return true;
     }
   }

   if (node is YamlList &&
       (node.style == CollectionStyle.BLOCK ||
           node.style == CollectionStyle.ANY)) {
     return true;
   }
   if (node is YamlMap &&
       (node.style == CollectionStyle.BLOCK ||
           node.style == CollectionStyle.ANY)) {
     return true;
   }

   return false;
 }

 /// Returns the content sensitive ending offset of [yamlNode] (i.e. where the
 /// last meaningful content happens)
 int getContentSensitiveEnd(YamlNode yamlNode) {
   if (yamlNode is YamlList) {
     if (yamlNode.style == CollectionStyle.FLOW) {
       return yamlNode.span.end.offset;
     } else {
       return getContentSensitiveEnd(yamlNode.nodes.last);
     }
   } else if (yamlNode is YamlMap) {
     if (yamlNode.style == CollectionStyle.FLOW) {
       return yamlNode.span.end.offset;
     } else {
       return getContentSensitiveEnd(yamlNode.nodes.values.last);
     }
   }

   return yamlNode.span.end.offset;
 }

 /// Checks if the item is a Map or a List
 bool isCollection(Object item) => item is Map || item is List;

 /// Checks if [index] is [int], >=0, < [length]
 bool isValidIndex(Object? index, int length) {
   return index is int && index >= 0 && index < length;
 }

 /// Checks if the item is empty, if it is a List or a Map.
 ///
 /// Returns `false` if [item] is not a List or Map.
 bool isEmpty(Object item) {
   if (item is Map) return item.isEmpty;
   if (item is List) return item.isEmpty;

   return false;
 }

 /// Creates a [SourceSpan] from [sourceUrl] with no meaningful location
 /// information.
 ///
 /// Mainly used with [wrapAsYamlNode] to allow for a reasonable
 /// implementation of [SourceSpan.message].
 SourceSpan shellSpan(Object? sourceUrl) {
   final shellSourceLocation = SourceLocation(0, sourceUrl: sourceUrl);
   return SourceSpanBase(shellSourceLocation, shellSourceLocation, '');
 }

 /// Returns if [value] is a [YamlList] or [YamlMap] with [CollectionStyle.FLOW].
 bool isFlowYamlCollectionNode(Object value) =>
     value is YamlNode && value.collectionStyle == CollectionStyle.FLOW;

 /// Determines the index where [newKey] will be inserted if the keys in [map]
 /// are in alphabetical order when converted to strings.
 ///
 /// Returns the length of [map] if the keys in [map] are not in alphabetical
 /// order.
 int getMapInsertionIndex(YamlMap map, Object newKey) {
   final keys = map.nodes.keys.map((k) => k.toString()).toList();

   // Detect if the keys are not already sorted, append new entry to the end
   for (var i = 1; i < keys.length; i++) {
     if (keys[i].compareTo(keys[i - 1]) < 0) {
       return map.length;
     }
   }

   final insertionIndex =
       keys.indexWhere((key) => key.compareTo(newKey as String) > 0);

   if (insertionIndex != -1) return insertionIndex;

   return map.length;
 }

 /// Returns the detected indentation step used in [editor], or defaults to a
 /// value of `2` if no indentation step can be detected.
 ///
 /// Indentation step is determined by the difference in indentation of the
 /// first block-styled yaml collection in the second level as compared to the
 /// top-level elements. In the case where there are multiple possible
 /// candidates, we choose the candidate closest to the start of [editor].
 int getIndentation(YamlEditor editor) {
   final node = editor.parseAt([]);
   Iterable<YamlNode>? children;
   var indentation = 2;

   if (node is YamlMap && node.style == CollectionStyle.BLOCK) {
     children = node.nodes.values;
   } else if (node is YamlList && node.style == CollectionStyle.BLOCK) {
     children = node.nodes;
   }

   if (children != null) {
     for (final child in children) {
       var indent = 0;
       if (child is YamlList) {
         indent = getListIndentation(editor.toString(), child);
       } else if (child is YamlMap) {
         indent = getMapIndentation(editor.toString(), child);
       }

       if (indent != 0) indentation = indent;
     }
   }
   return indentation;
 }

 /// Gets the indentation level of [list]. This is 0 if it is a flow list,
 /// but returns the number of spaces before the hyphen of elements for
 /// block lists.
 ///
 /// Throws [UnsupportedError] if an empty block map is passed in.
 int getListIndentation(String yaml, YamlList list) {
   if (list.style == CollectionStyle.FLOW) return 0;

   /// An empty block map doesn't really exist.
   if (list.isEmpty) {
     throw UnsupportedError('Unable to get indentation for empty block list');
   }

   final lastSpanOffset = list.nodes.last.span.start.offset;
   final lastHyphen = yaml.lastIndexOf('-', lastSpanOffset - 1);

   if (lastHyphen == 0) return lastHyphen;

   // Look for '\n' that's before hyphen
   final lastNewLine = yaml.lastIndexOf('\n', lastHyphen - 1);

   return lastHyphen - lastNewLine - 1;
 }

 /// Gets the indentation level of [map]. This is 0 if it is a flow map,
 /// but returns the number of spaces before the keys for block maps.
 int getMapIndentation(String yaml, YamlMap map) {
   if (map.style == CollectionStyle.FLOW) return 0;

   /// An empty block map doesn't really exist.
   if (map.isEmpty) {
     throw UnsupportedError('Unable to get indentation for empty block map');
   }

   /// Use the number of spaces between the last key and the newline as
   /// indentation.
   final lastKey = map.nodes.keys.last as YamlNode;
   final lastSpanOffset = lastKey.span.start.offset;
   final lastNewLine = yaml.lastIndexOf('\n', lastSpanOffset);
   final lastQuestionMark = yaml.lastIndexOf('?', lastSpanOffset);

   if (lastQuestionMark == -1) {
     if (lastNewLine == -1) return lastSpanOffset;
     return lastSpanOffset - lastNewLine - 1;
   }

   /// If there is a question mark, it might be a complex key. Check if it
   /// is on the same line as the key node to verify.
   if (lastNewLine == -1) return lastQuestionMark;
   if (lastQuestionMark > lastNewLine) {
     return lastQuestionMark - lastNewLine - 1;
   }

   return lastSpanOffset - lastNewLine - 1;
 }

 /// Returns the detected line ending used in [yaml], more specifically, whether
 /// [yaml] appears to use Windows `\r\n` or Unix `\n` line endings.
 ///
 /// The heuristic used is to count all `\n` in the text and if strictly more
 /// than half of them are preceded by `\r` we report that windows line endings
 /// are used.
 String getLineEnding(String yaml) {
   var index = -1;
   var unixNewlines = 0;
   var windowsNewlines = 0;
   while ((index = yaml.indexOf('\n', index + 1)) != -1) {
     if (index != 0 && yaml[index - 1] == '\r') {
       windowsNewlines++;
     } else {
       unixNewlines++;
     }
   }

   return windowsNewlines > unixNewlines ? '\r\n' : '\n';
 }

 final _nonSpaceMatch = RegExp(r'[^ \t]');

 /// Skip empty lines and returns the offset of the last possible line ending
 /// only if the [offset] is a valid offset within the [yaml] string that
 /// points to first line ending.
 ///
 /// The [blockIndent] is used to truncate any comments more indented than the
 /// parent collection that may affect other block entries within the collection
 /// that may have block scalars.
 int indexOfLastLineEnding(
   String yaml, {
   required int offset,
   required int blockIndent,
 }) {
   if (yaml.isEmpty || offset == -1) return yaml.length;

   final lastOffset = yaml.length - 1;
   var currentOffset = min(offset, lastOffset);

   // Unsafe. Cannot start our scanner state machine in an unguarded state.
   if (yaml[currentOffset] != '\r' && yaml[currentOffset] != '\n') {
     return currentOffset;
   }

   var lineEndingIndex = currentOffset;

   // Skip empty lines and any comments indented more than the block entry. Such
   // comments are hazardous to block scalars.
   scanner:
   while (currentOffset <= lastOffset) {
     switch (yaml[currentOffset]) {
       case '\r':
         {
           // Skip carriage return if possible. No use to us if we have a line
           // feed after.
           if (currentOffset < lastOffset && yaml[currentOffset + 1] == '\n') {
             ++currentOffset;
           }

           continue indentChecker;
         }

       indentChecker:
       case '\n':
         {
           lineEndingIndex = currentOffset;
           ++currentOffset;

           if (currentOffset >= lastOffset) {
             lineEndingIndex = lastOffset;
             break scanner;
           }

           final offsetAfterIndent = yaml.indexOf(RegExp('[^ ]'), currentOffset);

           // No more characters!
           if (offsetAfterIndent == -1) {
             lineEndingIndex = lastOffset;
             break scanner;
           }

           final indent = offsetAfterIndent - currentOffset;
           currentOffset = offsetAfterIndent;
           final charAfterIndent = yaml[currentOffset];

           if (charAfterIndent case '\r' || '\n') {
             continue scanner;
           } else if (indent > blockIndent) {
             // If more indented than the entry, always attempt to truncate the
             // comment or skip it as an empty line.
             if (charAfterIndent == '\t') {
               continue skipIfEmpty;
             } else if (charAfterIndent == '#') {
               continue truncateComment;
             }
           }

           break scanner;
         }

       // Guarded by indentChecker. Force tabs to be associated with empty lines
       // if seen past the indent.
       skipIfEmpty:
       case '\t':
         {
           final nonSpace = yaml.indexOf(_nonSpaceMatch, currentOffset);

           if (nonSpace == -1) {
             lineEndingIndex = lastOffset;
           } else if (yaml[nonSpace] case '\r' || '\n') {
             currentOffset = nonSpace;
             continue scanner;
           }

           break scanner;
         }

       // Guarded by indentChecker. This ensures we only skip comments indented
       // more than the entry itself.
       truncateComment:
       case '#':
         {
           final lineFeedOffset = yaml.indexOf('\n', currentOffset);

           if (lineFeedOffset == -1) {
             lineEndingIndex = lastOffset;
             break scanner;
           }

           currentOffset = lineFeedOffset;
           continue indentChecker;
         }

       default:
         break scanner;
     }
   }

   return lineEndingIndex;
 }

 /// Backtracks from the [start] offset and looks for the nearest character
 /// that is not a separation space (tab/space) that can be used to declare a
 /// nested compact block map
 ///
 /// ```yaml
 /// # In a block list
 /// - key: value
 ///   next: value
 ///
 /// ---
 /// # In an explicit key and its value
 ///
 /// ? key: value
 ///   next: value
 /// : key: value
 ///   next: value
 /// ```
 ///
 /// If a line feed `\n` is encountered first then `compactCharOffset` defaults
 /// to -1. Otherwise, only returns a non-negative `compactCharOffset` if
 /// `?`, `-` or `:` were seen.
 ({int compactCharOffset, int lineEndingIndex}) indexOfCompactChar(
   String yaml,
   int start,
 ) {
   /// Look back past the indent/separation space.
   final startOffset = max(
     0,
     yaml.lastIndexOf(_nonSpaceMatch, max(0, start - 1)),
   );

   return switch (yaml[startOffset]) {
     '\r' || '\n' => (compactCharOffset: -1, lineEndingIndex: startOffset),

     /// Block sequences and explicit keys/values can be used to declare block
     /// maps/sequences in a compact-inline notation.
     ///
     /// - a: b
     ///   c: d
     ///
     /// - - a
     ///   - b
     ///
     /// OR as an explicit key with its explicit value
     ///
     /// ? a: b
     ///   c: d
     /// : e: f
     ///   g: h
     ///
     /// ? - sequence
     ///   - as key
     /// : - sequence
     ///   - as value
     ///
     /// See "Example 8.19 Compact Block Mappings" at
     /// https://yaml.org/spec/1.2.2/#822-block-mappings
     '-' || '?' || ':' => (compactCharOffset: startOffset, lineEndingIndex: -1),
     _ => (compactCharOffset: -1, lineEndingIndex: -1)
   };
 }

 typedef NextBlockNodeInfo = ({int nearestLineEnding, int nextNodeColStart});
 typedef BlockNodeOffset = ({int start, int end});

 /// Removes a block entry and its line ending from a [blockCollection] using the
 /// [nodeToRemoveOffset] provided. Any trailing comments are also removed.
 ///
 /// If [blockCollection] is a [YamlMap], the chunk removed corresponds to the
 /// key-value pair represented by the offset. If [blockCollection] is a
 /// [YamlList], the chunk represents a single element within the list.
 ///
 /// [nextBlockNodeInfo] is only called if the [blockCollection] has at least
 /// 2 entries and the entry being removed is not the last entry in the
 /// collection.
 SourceEdit removeBlockCollectionEntry(
   String yaml, {
   required YamlNode blockCollection,
   required int collectionIndent,
   required bool isFirstEntry,
   required bool isSingleEntry,
   required bool isLastEntry,
   required BlockNodeOffset nodeToRemoveOffset,
   required String lineEnding,
   required NextBlockNodeInfo Function() nextBlockNodeInfo,
 }) {
   final isBlockList = blockCollection is YamlList;

   assert(
     isBlockList || blockCollection is YamlMap,
     'Expected a block map/list',
   );

   var makeNextNodeCompact = false;
   var (:start, :end) = nodeToRemoveOffset;

   // Skip empty lines to the last line break
   end = indexOfLastLineEnding(
     yaml,
     offset: yaml.indexOf('\n', end - 1),
     blockIndent: collectionIndent,
   );

   end = min(++end, yaml.length); // Mark it for removal

   if (isSingleEntry) {
     // Preserve when sandwiched or if an EOF line ending was present.
     if (end < yaml.length || yaml.endsWith('\n')) {
       end -= lineEnding == '\r\n' ? 2 : 1;
     }

     return SourceEdit(start, end - start, isBlockList ? '[]' : '{}');
   } else if (isLastEntry) {
     start = yaml.lastIndexOf('\n', start) + 1;
     end = max(yaml.lastIndexOf('\n', blockCollection.span.end.offset) + 1, end);
     return SourceEdit(start, end - start, '');
   }

   if (start != 0) {
     // Try making it compact in case the collection's parent is a:
     //    - block sequence
     //    - explicit key
     //    - explicit key's explicit value.
     if (isFirstEntry) {
       final (:compactCharOffset, :lineEndingIndex) = indexOfCompactChar(
         yaml,
         start,
       );

       if (compactCharOffset != -1) {
         start = compactCharOffset + 2; // Skip separation space.
         makeNextNodeCompact = true;
       } else {
         start = lineEndingIndex + 1;
       }
     } else {
       // If not possible, just consume this node's indent. This prevents this
       // node from interfering with the next node.
       start = yaml.lastIndexOf('\n', start) + 1;
     }
   }

   final (:nearestLineEnding, :nextNodeColStart) = nextBlockNodeInfo();
   final trueEndOffset = end - 1;

   // Make compact only if we are pointing to same line break from different
   // node extremes. This can only be true if we are removing the first
   // entry.
   //
   // ** For block lists **
   //
   // [*] Before:
   //
   // - - value
   //   - next
   //
   // [*] After:
   //
   // - - next
   //
   // ** For block maps **
   //
   // [*] Before:
   //
   // - key: value
   //   next: value
   //
   // [*] After:
   //
   // - next: value
   end = makeNextNodeCompact && nearestLineEnding == trueEndOffset
       ? end + nextNodeColStart
       : end;

   return SourceEdit(start, end - start, '');
 }

 extension YamlNodeExtension on YamlNode {
   /// Returns the [CollectionStyle] of `this` if `this` is [YamlMap] or
   /// [YamlList].
   ///
   /// Otherwise, returns `null`.
   CollectionStyle? get collectionStyle {
     final me = this;
     if (me is YamlMap) return me.style;
     if (me is YamlList) return me.style;
     return null;
   }
 }
	// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
	// for details. All rights reserved. Use of this source code is governed by a
	// BSD-style license that can be found in the LICENSE file.

	import 'dart:math';

	import 'package:source_span/source_span.dart';
	import 'package:yaml/yaml.dart';

	import 'editor.dart';
	import 'source_edit.dart';
	import 'wrap.dart';

	/// Invoke [fn] while setting [yamlWarningCallback] to [warn], and restore
	/// [YamlWarningCallback] after [fn] returns.
	///
	/// Defaults to a [warn] function that ignores all warnings.
	T withYamlWarningCallback<T>(
	T Function() fn, {
	YamlWarningCallback warn = _ignoreWarning,
	}) {
	final original = yamlWarningCallback;
	try {
	yamlWarningCallback = warn;
	return fn();
	} finally {
	yamlWarningCallback = original;
	}
	}

	void _ignoreWarning(String warning, [SourceSpan? span]) {/* ignore warning */}

	/// Determines if [string] is dangerous by checking if parsing the plain string
	/// can return a result different from [string].
	///
	/// This function is also capable of detecting if non-printable characters are
	/// in [string].
	bool isDangerousString(String string) {
	try {
	final node = withYamlWarningCallback(() => loadYamlNode(string));
	if (node.value != string) {
	return true;
	}

	// [string] should also not contain the `[`, `]`, `,`, `{` and `}` indicator
	// characters.
	return string.contains(RegExp(r'\{\|\[\|\]\|\}\|,'));
	} catch (e) {
	/// This catch statement catches [ArgumentError] in `loadYamlNode` when
	/// a string can be interpreted as a URI tag, but catches for other
	/// [YamlException]s
	return true;
	}
	}

	/// Asserts that [value] is a valid scalar according to YAML.
	///
	/// A valid scalar is a number, String, boolean, or null.
	void assertValidScalar(Object? value) {
	if (value is num \|\| value is String \|\| value is bool \|\| value == null) {
	return;
	}

	throw ArgumentError.value(value, 'value', 'Not a valid scalar type!');
	}

	/// Checks if [node] is a [YamlNode] with block styling.
	///
	/// [ScalarStyle.ANY] and [CollectionStyle.ANY] are considered to be block
	/// styling by default for maximum flexibility.
	bool isBlockNode(YamlNode node) {
	if (node is YamlScalar) {
	if (node.style == ScalarStyle.LITERAL \|\|
	node.style == ScalarStyle.FOLDED \|\|
	node.style == ScalarStyle.ANY) {
	return true;
	}
	}

	if (node is YamlList &&
	(node.style == CollectionStyle.BLOCK \|\|
	node.style == CollectionStyle.ANY)) {
	return true;
	}
	if (node is YamlMap &&
	(node.style == CollectionStyle.BLOCK \|\|
	node.style == CollectionStyle.ANY)) {
	return true;
	}

	return false;
	}

	/// Returns the content sensitive ending offset of [yamlNode] (i.e. where the
	/// last meaningful content happens)
	int getContentSensitiveEnd(YamlNode yamlNode) {
	if (yamlNode is YamlList) {
	if (yamlNode.style == CollectionStyle.FLOW) {
	return yamlNode.span.end.offset;
	} else {
	return getContentSensitiveEnd(yamlNode.nodes.last);
	}
	} else if (yamlNode is YamlMap) {
	if (yamlNode.style == CollectionStyle.FLOW) {
	return yamlNode.span.end.offset;
	} else {
	return getContentSensitiveEnd(yamlNode.nodes.values.last);
	}
	}

	return yamlNode.span.end.offset;
	}

	/// Checks if the item is a Map or a List
	bool isCollection(Object item) => item is Map \|\| item is List;

	/// Checks if [index] is [int], >=0, < [length]
	bool isValidIndex(Object? index, int length) {
	return index is int && index >= 0 && index < length;
	}

	/// Checks if the item is empty, if it is a List or a Map.
	///
	/// Returns `false` if [item] is not a List or Map.
	bool isEmpty(Object item) {
	if (item is Map) return item.isEmpty;
	if (item is List) return item.isEmpty;

	return false;
	}

	/// Creates a [SourceSpan] from [sourceUrl] with no meaningful location
	/// information.
	///
	/// Mainly used with [wrapAsYamlNode] to allow for a reasonable
	/// implementation of [SourceSpan.message].
	SourceSpan shellSpan(Object? sourceUrl) {
	final shellSourceLocation = SourceLocation(0, sourceUrl: sourceUrl);
	return SourceSpanBase(shellSourceLocation, shellSourceLocation, '');
	}

	/// Returns if [value] is a [YamlList] or [YamlMap] with [CollectionStyle.FLOW].
	bool isFlowYamlCollectionNode(Object value) =>
	value is YamlNode && value.collectionStyle == CollectionStyle.FLOW;

	/// Determines the index where [newKey] will be inserted if the keys in [map]
	/// are in alphabetical order when converted to strings.
	///
	/// Returns the length of [map] if the keys in [map] are not in alphabetical
	/// order.
	int getMapInsertionIndex(YamlMap map, Object newKey) {
	final keys = map.nodes.keys.map((k) => k.toString()).toList();

	// Detect if the keys are not already sorted, append new entry to the end
	for (var i = 1; i < keys.length; i++) {
	if (keys[i].compareTo(keys[i - 1]) < 0) {
	return map.length;
	}
	}

	final insertionIndex =
	keys.indexWhere((key) => key.compareTo(newKey as String) > 0);

	if (insertionIndex != -1) return insertionIndex;

	return map.length;
	}

	/// Returns the detected indentation step used in [editor], or defaults to a
	/// value of `2` if no indentation step can be detected.
	///
	/// Indentation step is determined by the difference in indentation of the
	/// first block-styled yaml collection in the second level as compared to the
	/// top-level elements. In the case where there are multiple possible
	/// candidates, we choose the candidate closest to the start of [editor].
	int getIndentation(YamlEditor editor) {
	final node = editor.parseAt([]);
	Iterable<YamlNode>? children;
	var indentation = 2;

	if (node is YamlMap && node.style == CollectionStyle.BLOCK) {
	children = node.nodes.values;
	} else if (node is YamlList && node.style == CollectionStyle.BLOCK) {
	children = node.nodes;
	}

	if (children != null) {
	for (final child in children) {
	var indent = 0;
	if (child is YamlList) {
	indent = getListIndentation(editor.toString(), child);
	} else if (child is YamlMap) {
	indent = getMapIndentation(editor.toString(), child);
	}

	if (indent != 0) indentation = indent;
	}
	}
	return indentation;
	}

	/// Gets the indentation level of [list]. This is 0 if it is a flow list,
	/// but returns the number of spaces before the hyphen of elements for
	/// block lists.
	///
	/// Throws [UnsupportedError] if an empty block map is passed in.
	int getListIndentation(String yaml, YamlList list) {
	if (list.style == CollectionStyle.FLOW) return 0;

	/// An empty block map doesn't really exist.
	if (list.isEmpty) {
	throw UnsupportedError('Unable to get indentation for empty block list');
	}

	final lastSpanOffset = list.nodes.last.span.start.offset;
	final lastHyphen = yaml.lastIndexOf('-', lastSpanOffset - 1);

	if (lastHyphen == 0) return lastHyphen;

	// Look for '\n' that's before hyphen
	final lastNewLine = yaml.lastIndexOf('\n', lastHyphen - 1);

	return lastHyphen - lastNewLine - 1;
	}

	/// Gets the indentation level of [map]. This is 0 if it is a flow map,
	/// but returns the number of spaces before the keys for block maps.
	int getMapIndentation(String yaml, YamlMap map) {
	if (map.style == CollectionStyle.FLOW) return 0;

	/// An empty block map doesn't really exist.
	if (map.isEmpty) {
	throw UnsupportedError('Unable to get indentation for empty block map');
	}

	/// Use the number of spaces between the last key and the newline as
	/// indentation.
	final lastKey = map.nodes.keys.last as YamlNode;
	final lastSpanOffset = lastKey.span.start.offset;
	final lastNewLine = yaml.lastIndexOf('\n', lastSpanOffset);
	final lastQuestionMark = yaml.lastIndexOf('?', lastSpanOffset);

	if (lastQuestionMark == -1) {
	if (lastNewLine == -1) return lastSpanOffset;
	return lastSpanOffset - lastNewLine - 1;
	}

	/// If there is a question mark, it might be a complex key. Check if it
	/// is on the same line as the key node to verify.
	if (lastNewLine == -1) return lastQuestionMark;
	if (lastQuestionMark > lastNewLine) {
	return lastQuestionMark - lastNewLine - 1;
	}

	return lastSpanOffset - lastNewLine - 1;
	}

	/// Returns the detected line ending used in [yaml], more specifically, whether
	/// [yaml] appears to use Windows `\r\n` or Unix `\n` line endings.
	///
	/// The heuristic used is to count all `\n` in the text and if strictly more
	/// than half of them are preceded by `\r` we report that windows line endings
	/// are used.
	String getLineEnding(String yaml) {
	var index = -1;
	var unixNewlines = 0;
	var windowsNewlines = 0;
	while ((index = yaml.indexOf('\n', index + 1)) != -1) {
	if (index != 0 && yaml[index - 1] == '\r') {
	windowsNewlines++;
	} else {
	unixNewlines++;
	}
	}

	return windowsNewlines > unixNewlines ? '\r\n' : '\n';
	}

	final _nonSpaceMatch = RegExp(r'[^ \t]');

	/// Skip empty lines and returns the offset of the last possible line ending
	/// only if the [offset] is a valid offset within the [yaml] string that
	/// points to first line ending.
	///
	/// The [blockIndent] is used to truncate any comments more indented than the
	/// parent collection that may affect other block entries within the collection
	/// that may have block scalars.
	int indexOfLastLineEnding(
	String yaml, {
	required int offset,
	required int blockIndent,
	}) {
	if (yaml.isEmpty \|\| offset == -1) return yaml.length;

	final lastOffset = yaml.length - 1;
	var currentOffset = min(offset, lastOffset);

	// Unsafe. Cannot start our scanner state machine in an unguarded state.
	if (yaml[currentOffset] != '\r' && yaml[currentOffset] != '\n') {
	return currentOffset;
	}

	var lineEndingIndex = currentOffset;

	// Skip empty lines and any comments indented more than the block entry. Such
	// comments are hazardous to block scalars.
	scanner:
	while (currentOffset <= lastOffset) {
	switch (yaml[currentOffset]) {
	case '\r':
	{
	// Skip carriage return if possible. No use to us if we have a line
	// feed after.
	if (currentOffset < lastOffset && yaml[currentOffset + 1] == '\n') {
	++currentOffset;
	}

	continue indentChecker;
	}

	indentChecker:
	case '\n':
	{
	lineEndingIndex = currentOffset;
	++currentOffset;

	if (currentOffset >= lastOffset) {
	lineEndingIndex = lastOffset;
	break scanner;
	}

	final offsetAfterIndent = yaml.indexOf(RegExp('[^ ]'), currentOffset);

	// No more characters!
	if (offsetAfterIndent == -1) {
	lineEndingIndex = lastOffset;
	break scanner;
	}

	final indent = offsetAfterIndent - currentOffset;
	currentOffset = offsetAfterIndent;
	final charAfterIndent = yaml[currentOffset];

	if (charAfterIndent case '\r' \|\| '\n') {
	continue scanner;
	} else if (indent > blockIndent) {
	// If more indented than the entry, always attempt to truncate the
	// comment or skip it as an empty line.
	if (charAfterIndent == '\t') {
	continue skipIfEmpty;
	} else if (charAfterIndent == '#') {
	continue truncateComment;
	}
	}

	break scanner;
	}

	// Guarded by indentChecker. Force tabs to be associated with empty lines
	// if seen past the indent.
	skipIfEmpty:
	case '\t':
	{
	final nonSpace = yaml.indexOf(_nonSpaceMatch, currentOffset);

	if (nonSpace == -1) {
	lineEndingIndex = lastOffset;
	} else if (yaml[nonSpace] case '\r' \|\| '\n') {
	currentOffset = nonSpace;
	continue scanner;
	}

	break scanner;
	}

	// Guarded by indentChecker. This ensures we only skip comments indented
	// more than the entry itself.
	truncateComment:
	case '#':
	{
	final lineFeedOffset = yaml.indexOf('\n', currentOffset);

	if (lineFeedOffset == -1) {
	lineEndingIndex = lastOffset;
	break scanner;
	}

	currentOffset = lineFeedOffset;
	continue indentChecker;
	}

	default:
	break scanner;
	}
	}

	return lineEndingIndex;
	}

	/// Backtracks from the [start] offset and looks for the nearest character
	/// that is not a separation space (tab/space) that can be used to declare a
	/// nested compact block map
	///
	/// ```yaml
	/// # In a block list
	/// - key: value
	/// next: value
	///
	/// ---
	/// # In an explicit key and its value
	///
	/// ? key: value
	/// next: value
	/// : key: value
	/// next: value
	/// ```
	///
	/// If a line feed `\n` is encountered first then `compactCharOffset` defaults
	/// to -1. Otherwise, only returns a non-negative `compactCharOffset` if
	/// `?`, `-` or `:` were seen.
	({int compactCharOffset, int lineEndingIndex}) indexOfCompactChar(
	String yaml,
	int start,
	) {
	/// Look back past the indent/separation space.
	final startOffset = max(
	0,
	yaml.lastIndexOf(_nonSpaceMatch, max(0, start - 1)),
	);

	return switch (yaml[startOffset]) {
	'\r' \|\| '\n' => (compactCharOffset: -1, lineEndingIndex: startOffset),

	/// Block sequences and explicit keys/values can be used to declare block
	/// maps/sequences in a compact-inline notation.
	///
	/// - a: b
	/// c: d
	///
	/// - - a
	/// - b
	///
	/// OR as an explicit key with its explicit value
	///
	/// ? a: b
	/// c: d
	/// : e: f
	/// g: h
	///
	/// ? - sequence
	/// - as key
	/// : - sequence
	/// - as value
	///
	/// See "Example 8.19 Compact Block Mappings" at
	/// https://yaml.org/spec/1.2.2/#822-block-mappings
	'-' \|\| '?' \|\| ':' => (compactCharOffset: startOffset, lineEndingIndex: -1),
	_ => (compactCharOffset: -1, lineEndingIndex: -1)
	};
	}

	typedef NextBlockNodeInfo = ({int nearestLineEnding, int nextNodeColStart});
	typedef BlockNodeOffset = ({int start, int end});

	/// Removes a block entry and its line ending from a [blockCollection] using the
	/// [nodeToRemoveOffset] provided. Any trailing comments are also removed.
	///
	/// If [blockCollection] is a [YamlMap], the chunk removed corresponds to the
	/// key-value pair represented by the offset. If [blockCollection] is a
	/// [YamlList], the chunk represents a single element within the list.
	///
	/// [nextBlockNodeInfo] is only called if the [blockCollection] has at least
	/// 2 entries and the entry being removed is not the last entry in the
	/// collection.
	SourceEdit removeBlockCollectionEntry(
	String yaml, {
	required YamlNode blockCollection,
	required int collectionIndent,
	required bool isFirstEntry,
	required bool isSingleEntry,
	required bool isLastEntry,
	required BlockNodeOffset nodeToRemoveOffset,
	required String lineEnding,
	required NextBlockNodeInfo Function() nextBlockNodeInfo,
	}) {
	final isBlockList = blockCollection is YamlList;

	assert(
	isBlockList \|\| blockCollection is YamlMap,
	'Expected a block map/list',
	);

	var makeNextNodeCompact = false;
	var (:start, :end) = nodeToRemoveOffset;

	// Skip empty lines to the last line break
	end = indexOfLastLineEnding(
	yaml,
	offset: yaml.indexOf('\n', end - 1),
	blockIndent: collectionIndent,
	);

	end = min(++end, yaml.length); // Mark it for removal

	if (isSingleEntry) {
	// Preserve when sandwiched or if an EOF line ending was present.
	if (end < yaml.length \|\| yaml.endsWith('\n')) {
	end -= lineEnding == '\r\n' ? 2 : 1;
	}

	return SourceEdit(start, end - start, isBlockList ? '[]' : '{}');
	} else if (isLastEntry) {
	start = yaml.lastIndexOf('\n', start) + 1;
	end = max(yaml.lastIndexOf('\n', blockCollection.span.end.offset) + 1, end);
	return SourceEdit(start, end - start, '');
	}

	if (start != 0) {
	// Try making it compact in case the collection's parent is a:
	// - block sequence
	// - explicit key
	// - explicit key's explicit value.
	if (isFirstEntry) {
	final (:compactCharOffset, :lineEndingIndex) = indexOfCompactChar(
	yaml,
	start,
	);

	if (compactCharOffset != -1) {
	start = compactCharOffset + 2; // Skip separation space.
	makeNextNodeCompact = true;
	} else {
	start = lineEndingIndex + 1;
	}
	} else {
	// If not possible, just consume this node's indent. This prevents this
	// node from interfering with the next node.
	start = yaml.lastIndexOf('\n', start) + 1;
	}
	}

	final (:nearestLineEnding, :nextNodeColStart) = nextBlockNodeInfo();
	final trueEndOffset = end - 1;

	// Make compact only if we are pointing to same line break from different
	// node extremes. This can only be true if we are removing the first
	// entry.
	//
	// For block lists
	//
	// [*] Before:
	//
	// - - value
	// - next
	//
	// [*] After:
	//
	// - - next
	//
	// For block maps
	//
	// [*] Before:
	//
	// - key: value
	// next: value
	//
	// [*] After:
	//
	// - next: value
	end = makeNextNodeCompact && nearestLineEnding == trueEndOffset
	? end + nextNodeColStart
	: end;

	return SourceEdit(start, end - start, '');
	}

	extension YamlNodeExtension on YamlNode {
	/// Returns the [CollectionStyle] of `this` if `this` is [YamlMap] or
	/// [YamlList].
	///
	/// Otherwise, returns `null`.
	CollectionStyle? get collectionStyle {
	final me = this;
	if (me is YamlMap) return me.style;
	if (me is YamlList) return me.style;
	return null;
	}
	}