diff --git a/lib/src/command/add.dart b/lib/src/command/add.dart
index faabf99..728f8ea 100644
--- a/lib/src/command/add.dart
+++ b/lib/src/command/add.dart
@@ -7,6 +7,7 @@
 import 'package:path/path.dart' as p;
 import 'package:pub_semver/pub_semver.dart';
 import 'package:yaml/yaml.dart';
+import 'package:yaml_edit/yaml_edit.dart';
 
 import '../command.dart';
 import '../entrypoint.dart';
@@ -20,7 +21,6 @@
 import '../solver.dart';
 import '../source/path.dart';
 import '../utils.dart';
-import '../yaml_edit/editor.dart';
 
 /// Handles the `add` pub command. Adds a dependency to `pubspec.yaml` and gets
 /// the package. The user may pass in a git constraint, host url, or path as
diff --git a/lib/src/command/remove.dart b/lib/src/command/remove.dart
index d1603d5..f505785 100644
--- a/lib/src/command/remove.dart
+++ b/lib/src/command/remove.dart
@@ -5,6 +5,7 @@
 // @dart=2.10
 
 import 'package:yaml/yaml.dart';
+import 'package:yaml_edit/yaml_edit.dart';
 
 import '../command.dart';
 import '../entrypoint.dart';
@@ -13,7 +14,6 @@
 import '../package.dart';
 import '../pubspec.dart';
 import '../solver.dart';
-import '../yaml_edit/editor.dart';
 
 /// Handles the `remove` pub command. Removes dependencies from `pubspec.yaml`,
 /// and performs an operation similar to `pub get`. Unlike `pub add`, this
diff --git a/lib/src/command/upgrade.dart b/lib/src/command/upgrade.dart
index 05b62f7..39a42c7 100644
--- a/lib/src/command/upgrade.dart
+++ b/lib/src/command/upgrade.dart
@@ -8,6 +8,7 @@
 import 'dart:io';
 
 import 'package:pub_semver/pub_semver.dart';
+import 'package:yaml_edit/yaml_edit.dart';
 
 import '../command.dart';
 import '../command_runner.dart';
@@ -22,7 +23,6 @@
 import '../pubspec_utils.dart';
 import '../solver.dart';
 import '../source/hosted.dart';
-import '../yaml_edit/editor.dart';
 
 /// Handles the `upgrade` pub command.
 class UpgradeCommand extends PubCommand {
diff --git a/lib/src/yaml_edit/editor.dart b/lib/src/yaml_edit/editor.dart
deleted file mode 100644
index e68cec1..0000000
--- a/lib/src/yaml_edit/editor.dart
+++ /dev/null
@@ -1,639 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:meta/meta.dart';
-import 'package:yaml/yaml.dart';
-
-import 'equality.dart';
-import 'errors.dart';
-import 'list_mutations.dart';
-import 'map_mutations.dart';
-import 'source_edit.dart';
-import 'strings.dart';
-import 'utils.dart';
-import 'wrap.dart';
-
-/// An interface for modififying [YAML][1] documents while preserving comments
-/// and whitespaces.
-///
-/// YAML parsing is supported by `package:yaml`, and modifications are performed
-/// as string operations. An error will be thrown if internal assertions fail -
-/// such a situation should be extremely rare, and should only occur with
-/// degenerate formatting.
-///
-/// Most modification methods require the user to pass in an [Iterable<Object>]
-/// path that holds the keys/indices to navigate to the element.
-///
-/// **Example:**
-/// ```yaml
-/// a: 1
-/// b: 2
-/// c:
-///   - 3
-///   - 4
-///   - {e: 5, f: [6, 7]}
-/// ```
-///
-/// To get to `7`, our path will be `['c', 2, 'f', 1]`. The path for the base
-/// object is the empty array `[]`. All modification methods will throw a
-/// [ArgumentError] if the path provided is invalid. Note also that that the
-/// order of elements in the path is important, and it should be arranged in
-/// order of calling, with the first element being the first key or index to be
-/// called.
-///
-/// In most modification methods, users are required to pass in a value to be
-/// used for updating the YAML tree. This value is only allowed to either be a
-/// valid scalar that is recognizable by YAML (i.e. `bool`, `String`, `List`,
-/// `Map`, `num`, `null`) or a [YamlNode]. Should the user want to specify
-/// the style to be applied to the value passed in, the user may wrap the value
-/// using [wrapAsYamlNode] while passing in the appropriate `scalarStyle` or
-/// `collectionStyle`. While we try to respect the style that is passed in,
-/// there will be instances where the formatting will not result in valid YAML,
-/// and as such we will fallback to a default formatting while preserving the
-/// content.
-///
-/// To dump the YAML after all the modifications have been completed, simply
-/// call [toString()].
-///
-/// [1]: https://yaml.org/
-@sealed
-class YamlEditor {
-  final List<SourceEdit> _edits = [];
-
-  /// List of [SourceEdit]s that have been applied to [_yaml] since the creation
-  /// of this instance, in chronological order. Intended to be compatible with
-  /// `package:analysis_server`.
-  ///
-  /// The [SourceEdit] objects can be serialized to JSON using the `toJSON`
-  /// function, deserialized using [SourceEdit.fromJson], and applied to a
-  /// string using the `apply` function. Multiple [SourceEdit]s can be applied
-  /// to a string using [SourceEdit.applyAll].
-  ///
-  /// For more information, refer to the [SourceEdit] class.
-  List<SourceEdit> get edits => [..._edits];
-
-  /// Current YAML string.
-  String _yaml;
-
-  /// Root node of YAML AST.
-  YamlNode _contents;
-
-  /// Stores the list of nodes in [_contents] that are connected by aliases.
-  ///
-  /// When a node is anchored with an alias and subsequently referenced,
-  /// the full content of the anchored node is thought to be copied in the
-  /// following references.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// a: &SS Sammy Sosa
-  /// b: *SS
-  /// ```
-  ///
-  /// is equivalent to
-  ///
-  /// ```dart
-  /// a: Sammy Sosa
-  /// b: Sammy Sosa
-  /// ```
-  ///
-  /// As such, aliased nodes have to be treated with special caution when
-  /// any modification is taking place.
-  ///
-  /// See 7.1 Alias Nodes: https://yaml.org/spec/1.2/spec.html#id2786196
-  Set<YamlNode> _aliases = {};
-
-  /// Returns the current YAML string.
-  @override
-  String toString() => _yaml;
-
-  factory YamlEditor(String yaml) => YamlEditor._(yaml);
-
-  YamlEditor._(this._yaml) {
-    ArgumentError.checkNotNull(_yaml);
-    _initialize();
-  }
-
-  /// Loads [_contents] from [_yaml], and traverses the YAML tree formed to
-  /// detect alias nodes.
-  void _initialize() {
-    _contents = loadYamlNode(_yaml);
-    _aliases = {};
-
-    /// Performs a DFS on [_contents] to detect alias nodes.
-    final visited = <YamlNode>{};
-    void collectAliases(YamlNode node) {
-      if (visited.add(node)) {
-        if (node is YamlMap) {
-          node.nodes.forEach((key, value) {
-            collectAliases(key);
-            collectAliases(value);
-          });
-        } else if (node is YamlList) {
-          node.nodes.forEach(collectAliases);
-        }
-      } else {
-        _aliases.add(node);
-      }
-    }
-
-    collectAliases(_contents);
-  }
-
-  /// Parses the document to return [YamlNode] currently present at [path].
-  ///
-  /// If no [YamlNode]s exist at [path], the result of invoking the [orElse]
-  /// function is returned.
-  ///
-  /// If [orElse] is omitted, it defaults to throwing a [ArgumentError].
-  ///
-  /// To get `null` when [path] does not point to a value in the [YamlNode]-tree,
-  /// simply pass `orElse: () => null`.
-  ///
-  /// **Example:** (using orElse)
-  /// ```dart
-  /// final myYamlEditor('{"key": "value"}');
-  /// final value = myYamlEditor.valueAt(['invalid', 'path'], orElse: () => null);
-  /// print(value) // null
-  /// ```
-  ///
-  /// **Example:** (common usage)
-  /// ```dart
-  ///   final doc = YamlEditor('''
-  /// a: 1
-  /// b:
-  ///   d: 4
-  ///   e: [5, 6, 7]
-  /// c: 3
-  /// ''');
-  /// print(doc.parseAt(['b', 'e', 2])); // 7
-  /// ```
-  /// The value returned by [parseAt] is invalidated when the documented is
-  /// mutated, as illustrated below:
-  ///
-  /// **Example:** (old [parseAt] value is invalidated)
-  /// ```dart
-  /// final doc = YamlEditor("YAML: YAML Ain't Markup Language");
-  /// final node = doc.parseAt(['YAML']);
-  ///
-  /// print(node.value); // Expected output: "YAML Ain't Markup Language"
-  ///
-  /// doc.update(['YAML'], 'YAML');
-  ///
-  /// final newNode = doc.parseAt(['YAML']);
-  ///
-  /// // Note that the value does not change
-  /// print(newNode.value); // "YAML"
-  /// print(node.value); // "YAML Ain't Markup Language"
-  /// ```
-  YamlNode parseAt(Iterable<Object> path, {YamlNode Function() orElse}) {
-    ArgumentError.checkNotNull(path, 'path');
-
-    return _traverse(path, orElse: orElse);
-  }
-
-  /// Sets [value] in the [path].
-  ///
-  /// There is a subtle difference between [update] and [remove] followed by
-  /// an [insertIntoList], because [update] preserves comments at the same level.
-  ///
-  /// Throws a [ArgumentError] if [path] is invalid.
-  ///
-  /// **Example:** (using [update])
-  /// ```dart
-  /// final doc = YamlEditor('''
-  ///   - 0
-  ///   - 1 # comment
-  ///   - 2
-  /// ''');
-  /// doc.update([1], 'test');
-  /// ```
-  ///
-  /// **Expected Output:**
-  /// ```yaml
-  ///   - 0
-  ///   - test # comment
-  ///   - 2
-  /// ```
-  ///
-  /// **Example:** (using [remove] and [insertIntoList])
-  /// ```dart
-  /// final doc2 = YamlEditor('''
-  ///   - 0
-  ///   - 1 # comment
-  ///   - 2
-  /// ''');
-  /// doc2.remove([1]);
-  /// doc2.insertIntoList([], 1, 'test');
-  /// ```
-  ///
-  /// **Expected Output:**
-  /// ```yaml
-  ///   - 0
-  ///   - test
-  ///   - 2
-  /// ```
-  void update(Iterable<Object> path, Object value) {
-    ArgumentError.checkNotNull(path, 'path');
-
-    final valueNode = wrapAsYamlNode(value);
-
-    if (path.isEmpty) {
-      final start = _contents.span.start.offset;
-      final end = getContentSensitiveEnd(_contents);
-      final lineEnding = getLineEnding(_yaml);
-      final edit = SourceEdit(
-          start, end - start, yamlEncodeBlockString(valueNode, 0, lineEnding));
-
-      return _performEdit(edit, path, valueNode);
-    }
-
-    final pathAsList = path.toList();
-    final collectionPath = pathAsList.take(path.length - 1);
-    final keyOrIndex = pathAsList.last;
-    final parentNode = _traverse(collectionPath, checkAlias: true);
-
-    if (parentNode is YamlList) {
-      final expected = wrapAsYamlNode(
-        [...parentNode.nodes]..[keyOrIndex] = valueNode,
-      );
-
-      return _performEdit(updateInList(this, parentNode, keyOrIndex, valueNode),
-          collectionPath, expected);
-    }
-
-    if (parentNode is YamlMap) {
-      final expectedMap =
-          updatedYamlMap(parentNode, (nodes) => nodes[keyOrIndex] = valueNode);
-      return _performEdit(updateInMap(this, parentNode, keyOrIndex, valueNode),
-          collectionPath, expectedMap);
-    }
-
-    throw PathError.unexpected(
-        path, 'Scalar $parentNode does not have key $keyOrIndex');
-  }
-
-  /// Appends [value] to the list at [path].
-  ///
-  /// Throws a [ArgumentError] if the element at the given path is not a
-  /// [YamlList] or if the path is invalid.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final doc = YamlEditor('[0, 1]');
-  /// doc.appendToList([], 2); // [0, 1, 2]
-  /// ```
-  void appendToList(Iterable<Object> path, Object value) {
-    ArgumentError.checkNotNull(path, 'path');
-    final yamlList = _traverseToList(path);
-
-    insertIntoList(path, yamlList.length, value);
-  }
-
-  /// Prepends [value] to the list at [path].
-  ///
-  /// Throws a [ArgumentError] if the element at the given path is not a
-  /// [YamlList] or if the path is invalid.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final doc = YamlEditor('[1, 2]');
-  /// doc.prependToList([], 0); // [0, 1, 2]
-  /// ```
-  void prependToList(Iterable<Object> path, Object value) {
-    ArgumentError.checkNotNull(path, 'path');
-
-    insertIntoList(path, 0, value);
-  }
-
-  /// Inserts [value] into the list at [path].
-  ///
-  /// [index] must be non-negative and no greater than the list's length.
-  ///
-  /// Throws a [ArgumentError] if the element at the given path is not a
-  /// [YamlList] or if the path is invalid.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final doc = YamlEditor('[0, 2]');
-  /// doc.insertIntoList([], 1, 1); // [0, 1, 2]
-  /// ```
-  void insertIntoList(Iterable<Object> path, int index, Object value) {
-    ArgumentError.checkNotNull(path, 'path');
-    final valueNode = wrapAsYamlNode(value);
-
-    final list = _traverseToList(path, checkAlias: true);
-    RangeError.checkValueInInterval(index, 0, list.length);
-
-    final edit = insertInList(this, list, index, valueNode);
-    final expected = wrapAsYamlNode(
-      [...list.nodes]..insert(index, valueNode),
-    );
-
-    _performEdit(edit, path, expected);
-  }
-
-  /// Changes the contents of the list at [path] by removing [deleteCount] items
-  /// at [index], and inserting [values] in-place. Returns the elements that
-  /// are deleted.
-  ///
-  /// [index] and [deleteCount] must be non-negative and [index] + [deleteCount]
-  /// must be no greater than the list's length.
-  ///
-  /// Throws a [ArgumentError] if the element at the given path is not a
-  /// [YamlList] or if the path is invalid.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final doc = YamlEditor('[Jan, March, April, June]');
-  /// doc.spliceList([], 1, 0, ['Feb']); // [Jan, Feb, March, April, June]
-  /// doc.spliceList([], 4, 1, ['May']); // [Jan, Feb, March, April, May]
-  /// ```
-  Iterable<YamlNode> spliceList(Iterable<Object> path, int index,
-      int deleteCount, Iterable<Object> values) {
-    ArgumentError.checkNotNull(path, 'path');
-    ArgumentError.checkNotNull(index, 'index');
-    ArgumentError.checkNotNull(deleteCount, 'deleteCount');
-    ArgumentError.checkNotNull(values, 'values');
-
-    final list = _traverseToList(path, checkAlias: true);
-
-    RangeError.checkValueInInterval(index, 0, list.length);
-    RangeError.checkValueInInterval(index + deleteCount, 0, list.length);
-
-    final nodesToRemove = list.nodes.getRange(index, index + deleteCount);
-
-    /// Perform addition of elements before removal to avoid scenarioes where
-    /// a block list gets emptied out to {} to avoid changing collection styles
-    /// where possible.
-
-    /// Reverse [values] and insert them.
-    final reversedValues = values.toList().reversed;
-    for (final value in reversedValues) {
-      insertIntoList(path, index, value);
-    }
-
-    for (var i = 0; i < deleteCount; i++) {
-      remove([...path, index + values.length]);
-    }
-
-    return nodesToRemove;
-  }
-
-  /// Removes the node at [path]. Comments "belonging" to the node will be
-  /// removed while surrounding comments will be left untouched.
-  ///
-  /// Throws a [ArgumentError] if [path] is invalid.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final doc = YamlEditor('''
-  /// - 0 # comment 0
-  /// # comment A
-  /// - 1 # comment 1
-  /// # comment B
-  /// - 2 # comment 2
-  /// ''');
-  /// doc.remove([1]);
-  /// ```
-  ///
-  /// **Expected Result:**
-  /// ```dart
-  /// '''
-  /// - 0 # comment 0
-  /// # comment A
-  /// # comment B
-  /// - 2 # comment 2
-  /// '''
-  /// ```
-  YamlNode remove(Iterable<Object> path) {
-    ArgumentError.checkNotNull(path, 'path');
-
-    SourceEdit edit;
-    YamlNode expectedNode;
-    final nodeToRemove = _traverse(path, checkAlias: true);
-
-    if (path.isEmpty) {
-      edit = SourceEdit(0, _yaml.length, '');
-
-      /// Parsing an empty YAML document returns `null`.
-      _performEdit(edit, path, expectedNode);
-      return nodeToRemove;
-    }
-
-    final pathAsList = path.toList();
-    final collectionPath = pathAsList.take(path.length - 1);
-    final keyOrIndex = pathAsList.last;
-    final parentNode = _traverse(collectionPath);
-
-    if (parentNode is YamlList) {
-      edit = removeInList(this, parentNode, keyOrIndex);
-      expectedNode = wrapAsYamlNode(
-        [...parentNode.nodes]..removeAt(keyOrIndex),
-      );
-    } else if (parentNode is YamlMap) {
-      edit = removeInMap(this, parentNode, keyOrIndex);
-
-      expectedNode =
-          updatedYamlMap(parentNode, (nodes) => nodes.remove(keyOrIndex));
-    }
-
-    _performEdit(edit, collectionPath, expectedNode);
-
-    return nodeToRemove;
-  }
-
-  /// Traverses down [path] to return the [YamlNode] at [path] if successful.
-  ///
-  /// If no [YamlNode]s exist at [path], the result of invoking the [orElse]
-  /// function is returned.
-  ///
-  /// If [orElse] is omitted, it defaults to throwing a [PathError].
-  ///
-  /// If [checkAlias] is `true`, throw [AliasError] if an aliased node is
-  /// encountered.
-  YamlNode _traverse(Iterable<Object> path,
-      {bool checkAlias = false, YamlNode Function() orElse}) {
-    ArgumentError.checkNotNull(path, 'path');
-    ArgumentError.checkNotNull(checkAlias, 'checkAlias');
-
-    if (path.isEmpty) return _contents;
-
-    var currentNode = _contents;
-    final pathList = path.toList();
-
-    for (var i = 0; i < pathList.length; i++) {
-      final keyOrIndex = pathList[i];
-
-      if (checkAlias && _aliases.contains(currentNode)) {
-        throw AliasError(path, currentNode);
-      }
-
-      if (currentNode is YamlList) {
-        final list = currentNode as YamlList;
-        if (!isValidIndex(keyOrIndex, list.length)) {
-          return _pathErrorOrElse(path, path.take(i + 1), list, orElse);
-        }
-
-        currentNode = list.nodes[keyOrIndex];
-      } else if (currentNode is YamlMap) {
-        final map = currentNode as YamlMap;
-
-        if (!containsKey(map, keyOrIndex)) {
-          return _pathErrorOrElse(path, path.take(i + 1), map, orElse);
-        }
-        final keyNode = getKeyNode(map, keyOrIndex);
-
-        if (checkAlias) {
-          if (_aliases.contains(keyNode)) throw AliasError(path, keyNode);
-        }
-
-        currentNode = map.nodes[keyNode];
-      } else {
-        return _pathErrorOrElse(path, path.take(i + 1), currentNode, orElse);
-      }
-    }
-
-    if (checkAlias) _assertNoChildAlias(path, currentNode);
-
-    return currentNode;
-  }
-
-  /// Throws a [PathError] if [orElse] is not provided, returns the result
-  /// of invoking the [orElse] function otherwise.
-  YamlNode _pathErrorOrElse(Iterable<Object> path, Iterable<Object> subPath,
-      YamlNode parent, YamlNode Function() orElse) {
-    if (orElse == null) throw PathError(path, subPath, parent);
-    return orElse();
-  }
-
-  /// Asserts that [node] and none its children are aliases
-  void _assertNoChildAlias(Iterable<Object> path, [YamlNode node]) {
-    ArgumentError.checkNotNull(path, 'path');
-
-    if (node == null) return _assertNoChildAlias(path, _traverse(path));
-    if (_aliases.contains(node)) throw AliasError(path, node);
-
-    if (node is YamlScalar) return;
-
-    if (node is YamlList) {
-      for (var i = 0; i < node.length; i++) {
-        final updatedPath = [...path, i];
-        _assertNoChildAlias(updatedPath, node.nodes[i]);
-      }
-    }
-
-    if (node is YamlMap) {
-      final keyList = node.keys.toList();
-      for (var i = 0; i < node.length; i++) {
-        final updatedPath = [...path, keyList[i]];
-        if (_aliases.contains(keyList[i])) throw AliasError(path, keyList[i]);
-        _assertNoChildAlias(updatedPath, node.nodes[keyList[i]]);
-      }
-    }
-  }
-
-  /// Traverses down the provided [path] to return the [YamlList] at [path].
-  ///
-  /// Convenience function to ensure that a [YamlList] is returned.
-  ///
-  /// Throws [ArgumentError] if the element at the given path is not a
-  /// [YamlList] or if the path is invalid. If [checkAlias] is `true`, and an
-  /// aliased node is encountered along [path], an [AliasError] will be thrown.
-  YamlList _traverseToList(Iterable<Object> path, {bool checkAlias = false}) {
-    ArgumentError.checkNotNull(path, 'path');
-    ArgumentError.checkNotNull(checkAlias, 'checkAlias');
-
-    final possibleList = _traverse(path, checkAlias: true);
-
-    if (possibleList is YamlList) {
-      return possibleList;
-    } else {
-      throw PathError.unexpected(
-          path, 'Path $path does not point to a YamlList!');
-    }
-  }
-
-  /// Utility method to replace the substring of [_yaml] according to [edit].
-  ///
-  /// When [_yaml] is modified with this method, the resulting string is parsed
-  /// and reloaded and traversed down [path] to ensure that the reloaded YAML
-  /// tree is equal to our expectations by deep equality of values. Throws an
-  /// [AssertionError] if the two trees do not match.
-  void _performEdit(
-      SourceEdit edit, Iterable<Object> path, YamlNode expectedNode) {
-    ArgumentError.checkNotNull(edit, 'edit');
-    ArgumentError.checkNotNull(path, 'path');
-
-    final expectedTree = _deepModify(_contents, path, [], expectedNode);
-    final initialYaml = _yaml;
-    _yaml = edit.apply(_yaml);
-
-    try {
-      _initialize();
-    } on YamlException {
-      throw createAssertionError(
-          'Failed to produce valid YAML after modification.',
-          initialYaml,
-          _yaml);
-    }
-
-    final actualTree = loadYamlNode(_yaml);
-    if (!deepEquals(actualTree, expectedTree)) {
-      throw createAssertionError(
-          'Modification did not result in expected result.',
-          initialYaml,
-          _yaml);
-    }
-    _contents = actualTree;
-    _edits.add(edit);
-  }
-
-  /// Utility method to produce an updated YAML tree equivalent to converting
-  /// the [YamlNode] at [path] to be [expectedNode]. [subPath] holds the portion
-  /// of [path] that has been traversed thus far.
-  ///
-  /// Throws a [PathError] if path is invalid.
-  ///
-  /// When called, it creates a new [YamlNode] of the same type as [tree], and
-  /// copies its children over, except for the child that is on the path. Doing
-  /// so allows us to "update" the immutable [YamlNode] without having to clone
-  /// the whole tree.
-  ///
-  /// [SourceSpan]s in this new tree are not guaranteed to be accurate.
-  YamlNode _deepModify(YamlNode tree, Iterable<Object> path,
-      Iterable<Object> subPath, YamlNode expectedNode) {
-    ArgumentError.checkNotNull(path, 'path');
-    ArgumentError.checkNotNull(tree, 'tree');
-    RangeError.checkValueInInterval(subPath.length, 0, path.length);
-
-    if (path.length == subPath.length) return expectedNode;
-
-    final keyOrIndex = path.elementAt(subPath.length);
-
-    if (tree is YamlList) {
-      if (!isValidIndex(keyOrIndex, tree.length)) {
-        throw PathError(path, subPath, tree);
-      }
-
-      return wrapAsYamlNode([...tree.nodes]..[keyOrIndex] = _deepModify(
-          tree.nodes[keyOrIndex],
-          path,
-          path.take(subPath.length + 1),
-          expectedNode));
-    }
-
-    if (tree is YamlMap) {
-      return updatedYamlMap(
-          tree,
-          (nodes) => nodes[keyOrIndex] = _deepModify(nodes[keyOrIndex], path,
-              path.take(subPath.length + 1), expectedNode));
-    }
-
-    /// Should not ever reach here.
-    throw PathError(path, subPath, tree);
-  }
-}
diff --git a/lib/src/yaml_edit/equality.dart b/lib/src/yaml_edit/equality.dart
deleted file mode 100644
index e7cce40..0000000
--- a/lib/src/yaml_edit/equality.dart
+++ /dev/null
@@ -1,118 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'dart:collection';
-
-import 'package:collection/collection.dart';
-import 'package:yaml/yaml.dart';
-
-/// Creates a map that uses our custom [deepEquals] and [deepHashCode] functions
-/// to determine equality.
-Map<K, V> deepEqualsMap<K, V>() =>
-    LinkedHashMap(equals: deepEquals, hashCode: deepHashCode);
-
-/// Compares two [Object]s for deep equality. This implementation differs from
-/// `package:yaml`'s deep equality notation by allowing for comparison of
-/// non-scalar map keys.
-bool deepEquals(dynamic obj1, dynamic obj2) {
-  if (obj1 is YamlNode) obj1 = obj1.value;
-  if (obj2 is YamlNode) obj2 = obj2.value;
-
-  if (obj1 is Map && obj2 is Map) {
-    return mapDeepEquals(obj1, obj2);
-  }
-
-  if (obj1 is List && obj2 is List) {
-    return listDeepEquals(obj1, obj2);
-  }
-
-  return obj1 == obj2;
-}
-
-/// Compares two [List]s for deep equality.
-bool listDeepEquals(List list1, List list2) {
-  if (list1.length != list2.length) return false;
-
-  if (list1 is YamlList) list1 = (list1 as YamlList).nodes;
-  if (list2 is YamlList) list2 = (list2 as YamlList).nodes;
-
-  for (var i = 0; i < list1.length; i++) {
-    if (!deepEquals(list1[i], list2[i])) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/// Compares two [Map]s for deep equality. Differs from `package:yaml`'s deep
-/// equality notation by allowing for comparison of non-scalar map keys.
-bool mapDeepEquals(Map map1, Map map2) {
-  if (map1.length != map2.length) return false;
-
-  if (map1 is YamlList) map1 = (map1 as YamlMap).nodes;
-  if (map2 is YamlList) map2 = (map2 as YamlMap).nodes;
-
-  return map1.keys.every((key) {
-    if (!containsKey(map2, key)) return false;
-
-    /// Because two keys may be equal by deep equality but using one key on the
-    /// other map might not get a hit since they may not be both using our
-    /// [deepEqualsMap].
-    final key2 = getKey(map2, key);
-
-    if (!deepEquals(map1[key], map2[key2])) {
-      return false;
-    }
-
-    return true;
-  });
-}
-
-/// Returns a hashcode for [value] such that structures that are equal by
-/// [deepEquals] will have the same hash code.
-int deepHashCode(Object value) {
-  if (value is Map) {
-    const equality = UnorderedIterableEquality();
-    return equality.hash(value.keys.map(deepHashCode)) ^
-        equality.hash(value.values.map(deepHashCode));
-  } else if (value is Iterable) {
-    return const IterableEquality().hash(value.map(deepHashCode));
-  } else if (value is YamlScalar) {
-    return value.value.hashCode;
-  }
-
-  return value.hashCode;
-}
-
-/// Returns the [YamlNode] corresponding to the provided [key].
-YamlNode getKeyNode(YamlMap map, Object key) {
-  return map.nodes.keys.firstWhere((node) => deepEquals(node, key)) as YamlNode;
-}
-
-/// Returns the [YamlNode] after the [YamlNode] corresponding to the provided
-/// [key].
-YamlNode getNextKeyNode(YamlMap map, Object key) {
-  final keyIterator = map.nodes.keys.iterator;
-  while (keyIterator.moveNext()) {
-    if (deepEquals(keyIterator.current, key) && keyIterator.moveNext()) {
-      return keyIterator.current;
-    }
-  }
-
-  return null;
-}
-
-/// Returns the key in [map] that is equal to the provided [key] by the notion
-/// of deep equality.
-Object getKey(Map map, Object key) {
-  return map.keys.firstWhere((k) => deepEquals(k, key));
-}
-
-/// Checks if [map] has any keys equal to the provided [key] by deep equality.
-bool containsKey(Map map, Object key) {
-  return map.keys.where((node) => deepEquals(node, key)).isNotEmpty;
-}
diff --git a/lib/src/yaml_edit/errors.dart b/lib/src/yaml_edit/errors.dart
deleted file mode 100644
index 7d490a9..0000000
--- a/lib/src/yaml_edit/errors.dart
+++ /dev/null
@@ -1,102 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:meta/meta.dart';
-import 'package:yaml/yaml.dart';
-
-/// Error thrown when a function is passed an invalid path.
-@sealed
-class PathError extends ArgumentError {
-  /// The full path that caused the error
-  final Iterable<Object> path;
-
-  /// The subpath that caused the error
-  final Iterable<Object> subPath;
-
-  /// The last element of [path] that could be traversed.
-  YamlNode parent;
-
-  PathError(this.path, this.subPath, this.parent, [String message])
-      : super.value(subPath, 'path', message);
-
-  PathError.unexpected(this.path, String message)
-      : subPath = path,
-        super(message);
-
-  @override
-  String toString() {
-    if (message == null) {
-      var errorMessage = 'Failed to traverse to subpath $subPath!';
-
-      if (subPath.isNotEmpty) {
-        errorMessage +=
-            ' Parent $parent does not contain key or index ${subPath.last}';
-      }
-
-      return 'Invalid path: $path. $errorMessage.';
-    }
-
-    return 'Invalid path: $path. $message';
-  }
-}
-
-/// Error thrown when the path contains an alias along the way.
-///
-/// When a path contains an aliased node, the behavior becomes less well-defined
-/// because we cannot be certain if the user wishes for the change to
-/// propagate throughout all the other aliased nodes, or if the user wishes
-/// for only that particular node to be modified. As such, [AliasError] reflects
-/// the detection that our change will impact an alias, and we do not intend
-/// on supporting such changes for the foreseeable future.
-@sealed
-class AliasError extends UnsupportedError {
-  /// The path that caused the error
-  final Iterable<Object> path;
-
-  /// The anchor node of the alias
-  final YamlNode anchor;
-
-  AliasError(this.path, this.anchor)
-      : super('Encountered an alias node along $path! '
-            'Alias nodes are nodes that refer to a previously serialized nodes, '
-            'and are denoted by either the "*" or the "&" indicators in the '
-            'original YAML. As the resulting behavior of mutations on these '
-            'nodes is not well-defined, the operation will not be supported '
-            'by this library.\n\n'
-            '${anchor.span.message('The alias was first defined here.')}');
-}
-
-/// Error thrown when an assertion about the YAML fails. Extends
-/// [AssertionError] to override the [toString] method for pretty printing.
-class _YamlAssertionError extends AssertionError {
-  _YamlAssertionError(message) : super(message);
-
-  @override
-  String toString() {
-    if (message != null) {
-      return 'Assertion failed: $message';
-    }
-    return 'Assertion failed';
-  }
-}
-
-/// Throws an [AssertionError] with the given [message], and format
-/// [oldYaml] and [newYaml] for information.
-Error createAssertionError(String message, String oldYaml, String newYaml) {
-  return _YamlAssertionError('''
-(package:yaml_edit) $message
-
-# YAML before edit:
-> ${oldYaml.replaceAll('\n', '\n> ')}
-
-# YAML after edit:
-> ${newYaml.replaceAll('\n', '\n> ')}
-
-Please file an issue at:
-'''
-      'https://github.com/google/dart-neats/issues/new?labels=pkg%3Ayaml_edit'
-      '%2C+pending-triage&template=yaml_edit.md\n');
-}
diff --git a/lib/src/yaml_edit/list_mutations.dart b/lib/src/yaml_edit/list_mutations.dart
deleted file mode 100644
index 224b87c..0000000
--- a/lib/src/yaml_edit/list_mutations.dart
+++ /dev/null
@@ -1,337 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:yaml/yaml.dart';
-
-import 'editor.dart';
-import 'source_edit.dart';
-import 'strings.dart';
-import 'utils.dart';
-import 'wrap.dart';
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of setting the element at [index] to [newValue] when re-parsed.
-SourceEdit updateInList(
-    YamlEditor yamlEdit, YamlList list, int index, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length - 1);
-
-  final currValue = list.nodes[index];
-  var offset = currValue.span.start.offset;
-  final yaml = yamlEdit.toString();
-  String valueString;
-
-  /// We do not use [_formatNewBlock] since we want to only replace the contents
-  /// of this node while preserving comments/whitespace, while [_formatNewBlock]
-  /// produces a string representation of a new node.
-  if (list.style == CollectionStyle.BLOCK) {
-    final listIndentation = getListIndentation(yaml, list);
-    final indentation = listIndentation + getIndentation(yamlEdit);
-    final lineEnding = getLineEnding(yaml);
-    valueString = yamlEncodeBlockString(
-        wrapAsYamlNode(newValue), indentation, lineEnding);
-
-    /// We prefer the compact nested notation for collections.
-    ///
-    /// By virtue of [yamlEncodeBlockString], collections automatically
-    /// have the necessary line endings.
-    if ((newValue is List && (newValue as List).isNotEmpty) ||
-        (newValue is Map && (newValue as Map).isNotEmpty)) {
-      valueString = valueString.substring(indentation);
-    } else if (isCollection(currValue) &&
-        getStyle(currValue) == CollectionStyle.BLOCK) {
-      valueString += lineEnding;
-    }
-
-    var end = getContentSensitiveEnd(currValue);
-    if (end <= offset) {
-      offset++;
-      end = offset;
-      valueString = ' ' + valueString;
-    }
-
-    return SourceEdit(offset, end - offset, valueString);
-  } else {
-    valueString = yamlEncodeFlowString(newValue);
-    return SourceEdit(offset, currValue.span.length, valueString);
-  }
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of appending [item] to the list.
-SourceEdit appendIntoList(YamlEditor yamlEdit, YamlList list, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-
-  if (list.style == CollectionStyle.FLOW) {
-    return _appendToFlowList(yamlEdit, list, item);
-  } else {
-    return _appendToBlockList(yamlEdit, list, item);
-  }
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of inserting [item] to the list at [index].
-SourceEdit insertInList(
-    YamlEditor yamlEdit, YamlList list, int index, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length);
-
-  /// We call the append method if the user wants to append it to the end of the
-  /// list because appending requires different techniques.
-  if (index == list.length) {
-    return appendIntoList(yamlEdit, list, item);
-  } else {
-    if (list.style == CollectionStyle.FLOW) {
-      return _insertInFlowList(yamlEdit, list, index, item);
-    } else {
-      return _insertInBlockList(yamlEdit, list, index, item);
-    }
-  }
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of removing the element at [index] when re-parsed.
-SourceEdit removeInList(YamlEditor yamlEdit, YamlList list, int index) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-
-  final nodeToRemove = list.nodes[index];
-
-  if (list.style == CollectionStyle.FLOW) {
-    return _removeFromFlowList(yamlEdit, list, nodeToRemove, index);
-  } else {
-    return _removeFromBlockList(yamlEdit, list, nodeToRemove, index);
-  }
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of addition [item] into [nodes], noting that this is a flow list.
-SourceEdit _appendToFlowList(
-    YamlEditor yamlEdit, YamlList list, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-
-  final valueString = _formatNewFlow(list, item, true);
-  return SourceEdit(list.span.end.offset - 1, 0, valueString);
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of addition [item] into [nodes], noting that this is a block list.
-SourceEdit _appendToBlockList(
-    YamlEditor yamlEdit, YamlList list, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-
-  var formattedValue = _formatNewBlock(yamlEdit, list, item);
-  final yaml = yamlEdit.toString();
-  var offset = list.span.end.offset;
-
-  // Adjusts offset to after the trailing newline of the last entry, if it exists
-  if (list.isNotEmpty) {
-    final lastValueSpanEnd = list.nodes.last.span.end.offset;
-    final nextNewLineIndex = yaml.indexOf('\n', lastValueSpanEnd);
-    if (nextNewLineIndex == -1) {
-      formattedValue = getLineEnding(yaml) + formattedValue;
-    } else {
-      offset = nextNewLineIndex + 1;
-    }
-  }
-
-  return SourceEdit(offset, 0, formattedValue);
-}
-
-/// Formats [item] into a new node for block lists.
-String _formatNewBlock(YamlEditor yamlEdit, YamlList list, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-
-  final yaml = yamlEdit.toString();
-  final listIndentation = getListIndentation(yaml, list);
-  final newIndentation = listIndentation + getIndentation(yamlEdit);
-  final lineEnding = getLineEnding(yaml);
-
-  var valueString = yamlEncodeBlockString(item, newIndentation, lineEnding);
-  if (isCollection(item) && !isFlowYamlCollectionNode(item) && !isEmpty(item)) {
-    valueString = valueString.substring(newIndentation);
-  }
-  final indentedHyphen = ' ' * listIndentation + '- ';
-
-  return '$indentedHyphen$valueString$lineEnding';
-}
-
-/// Formats [item] into a new node for flow lists.
-String _formatNewFlow(YamlList list, YamlNode item, [bool isLast = false]) {
-  ArgumentError.checkNotNull(list, 'list');
-  ArgumentError.checkNotNull(isLast, 'isLast');
-
-  var valueString = yamlEncodeFlowString(item);
-  if (list.isNotEmpty) {
-    if (isLast) {
-      valueString = ', $valueString';
-    } else {
-      valueString += ', ';
-    }
-  }
-
-  return valueString;
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of inserting [item] into [nodes] at [index], noting that this is
-/// a block list.
-///
-/// [index] should be non-negative and less than or equal to [length].
-SourceEdit _insertInBlockList(
-    YamlEditor yamlEdit, YamlList list, int index, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length);
-
-  if (index == list.length) return _appendToBlockList(yamlEdit, list, item);
-
-  final formattedValue = _formatNewBlock(yamlEdit, list, item);
-
-  final currNode = list.nodes[index];
-  final currNodeStart = currNode.span.start.offset;
-  final yaml = yamlEdit.toString();
-  final start = yaml.lastIndexOf('\n', currNodeStart) + 1;
-
-  return SourceEdit(start, 0, formattedValue);
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of inserting [item] into [nodes] at [index], noting that this is
-/// a flow list.
-///
-/// [index] should be non-negative and less than or equal to [length].
-SourceEdit _insertInFlowList(
-    YamlEditor yamlEdit, YamlList list, int index, YamlNode item) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length);
-
-  if (index == list.length) return _appendToFlowList(yamlEdit, list, item);
-
-  final formattedValue = _formatNewFlow(list, item);
-
-  final yaml = yamlEdit.toString();
-  final currNode = list.nodes[index];
-  final currNodeStart = currNode.span.start.offset;
-  var start = yaml.lastIndexOf(RegExp(r',|\['), currNodeStart - 1) + 1;
-  if (yaml[start] == ' ') start++;
-
-  return SourceEdit(start, 0, formattedValue);
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of removing [nodeToRemove] from [nodes], noting that this is a
-/// block list.
-///
-/// [index] should be non-negative and less than or equal to [length].
-SourceEdit _removeFromBlockList(
-    YamlEditor yamlEdit, YamlList list, YamlNode nodeToRemove, int index) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length - 1);
-
-  var end = getContentSensitiveEnd(nodeToRemove);
-
-  /// If we are removing the last element in a block list, convert it into a
-  /// flow empty list.
-  if (list.length == 1) {
-    final start = list.span.start.offset;
-
-    return SourceEdit(start, end - start, '[]');
-  }
-
-  final yaml = yamlEdit.toString();
-  final span = nodeToRemove.span;
-
-  /// Adjust the end to clear the new line after the end too.
-  ///
-  /// We do this because we suspect that our users will want the inline
-  /// comments to disappear too.
-  final nextNewLine = yaml.indexOf('\n', end);
-  if (nextNewLine != -1) {
-    end = nextNewLine + 1;
-  }
-
-  /// If the value is empty
-  if (span.length == 0) {
-    var start = span.start.offset;
-    return SourceEdit(start, end - start, '');
-  }
-
-  /// -1 accounts for the fact that the content can start with a dash
-  var start = yaml.lastIndexOf('-', span.start.offset - 1);
-
-  /// Check if there is a `-` before the node
-  if (start > 0) {
-    final lastHyphen = yaml.lastIndexOf('-', start - 1);
-    final lastNewLine = yaml.lastIndexOf('\n', start - 1);
-    if (lastHyphen > lastNewLine) {
-      start = lastHyphen + 2;
-
-      /// If there is a `-` before the node, we need to check if we have
-      /// to update the indentation of the next node.
-      if (index < list.length - 1) {
-        /// Since [end] is currently set to the next new line after the current
-        /// node, check if we see a possible comment first, or a hyphen first.
-        /// Note that no actual content can appear here.
-        ///
-        /// We check this way because the start of a span in a block list is
-        /// the start of its value, and checking from the back leaves us
-        /// easily confused if there are comments that have dashes in them.
-        final nextHash = yaml.indexOf('#', end);
-        final nextHyphen = yaml.indexOf('-', end);
-        final nextNewLine = yaml.indexOf('\n', end);
-
-        /// If [end] is on the same line as the hyphen of the next node
-        if ((nextHash == -1 || nextHyphen < nextHash) &&
-            nextHyphen < nextNewLine) {
-          end = nextHyphen;
-        }
-      }
-    } else if (lastNewLine > lastHyphen) {
-      start = lastNewLine + 1;
-    }
-  }
-
-  return SourceEdit(start, end - start, '');
-}
-
-/// Returns a [SourceEdit] describing the change to be made on [yaml] to achieve
-/// the effect of removing [nodeToRemove] from [nodes], noting that this is a
-/// flow list.
-///
-/// [index] should be non-negative and less than or equal to [length].
-SourceEdit _removeFromFlowList(
-    YamlEditor yamlEdit, YamlList list, YamlNode nodeToRemove, int index) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(list, 'list');
-  RangeError.checkValueInInterval(index, 0, list.length - 1);
-
-  final span = nodeToRemove.span;
-  final yaml = yamlEdit.toString();
-  var start = span.start.offset;
-  var end = span.end.offset;
-
-  if (index == 0) {
-    start = yaml.lastIndexOf('[', start - 1) + 1;
-    if (index == list.length - 1) {
-      end = yaml.indexOf(']', end);
-    } else {
-      end = yaml.indexOf(',', end) + 1;
-    }
-  } else {
-    start = yaml.lastIndexOf(',', start - 1);
-  }
-
-  return SourceEdit(start, end - start, '');
-}
diff --git a/lib/src/yaml_edit/map_mutations.dart b/lib/src/yaml_edit/map_mutations.dart
deleted file mode 100644
index 597c0ba..0000000
--- a/lib/src/yaml_edit/map_mutations.dart
+++ /dev/null
@@ -1,264 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:yaml/yaml.dart';
-
-import 'editor.dart';
-import 'equality.dart';
-import 'source_edit.dart';
-import 'strings.dart';
-import 'utils.dart';
-import 'wrap.dart';
-
-/// Performs the string operation on [yaml] to achieve the effect of setting
-/// the element at [key] to [newValue] when re-parsed.
-SourceEdit updateInMap(
-    YamlEditor yamlEdit, YamlMap map, Object key, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  if (!containsKey(map, key)) {
-    final keyNode = wrapAsYamlNode(key);
-
-    if (map.style == CollectionStyle.FLOW) {
-      return _addToFlowMap(yamlEdit, map, keyNode, newValue);
-    } else {
-      return _addToBlockMap(yamlEdit, map, keyNode, newValue);
-    }
-  } else {
-    if (map.style == CollectionStyle.FLOW) {
-      return _replaceInFlowMap(yamlEdit, map, key, newValue);
-    } else {
-      return _replaceInBlockMap(yamlEdit, map, key, newValue);
-    }
-  }
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of removing
-/// the element at [key] when re-parsed.
-SourceEdit removeInMap(YamlEditor yamlEdit, YamlMap map, Object key) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  if (!containsKey(map, key)) return null;
-
-  final keyNode = getKeyNode(map, key);
-  final valueNode = map.nodes[keyNode];
-
-  if (map.style == CollectionStyle.FLOW) {
-    return _removeFromFlowMap(yamlEdit, map, keyNode, valueNode);
-  } else {
-    return _removeFromBlockMap(yamlEdit, map, keyNode, valueNode);
-  }
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of adding
-/// the [key]:[newValue] pair when reparsed, bearing in mind that this is a
-/// block map.
-SourceEdit _addToBlockMap(
-    YamlEditor yamlEdit, YamlMap map, Object key, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  final yaml = yamlEdit.toString();
-  final newIndentation =
-      getMapIndentation(yaml, map) + getIndentation(yamlEdit);
-  final keyString = yamlEncodeFlowString(wrapAsYamlNode(key));
-  final lineEnding = getLineEnding(yaml);
-
-  var valueString = yamlEncodeBlockString(newValue, newIndentation, lineEnding);
-  if (isCollection(newValue) &&
-      !isFlowYamlCollectionNode(newValue) &&
-      !isEmpty(newValue)) {
-    valueString = '$lineEnding$valueString';
-  }
-
-  var formattedValue = ' ' * getMapIndentation(yaml, map) + '$keyString: ';
-  var offset = map.span.end.offset;
-
-  final insertionIndex = getMapInsertionIndex(map, keyString);
-
-  if (map.isNotEmpty) {
-    /// Adjusts offset to after the trailing newline of the last entry, if it
-    /// exists
-    if (insertionIndex == map.length) {
-      final lastValueSpanEnd = getContentSensitiveEnd(map.nodes.values.last);
-      final nextNewLineIndex = yaml.indexOf('\n', lastValueSpanEnd);
-
-      if (nextNewLineIndex != -1) {
-        offset = nextNewLineIndex + 1;
-      } else {
-        formattedValue = lineEnding + formattedValue;
-      }
-    } else {
-      final keyAtIndex = map.nodes.keys.toList()[insertionIndex] as YamlNode;
-      final keySpanStart = keyAtIndex.span.start.offset;
-      final prevNewLineIndex = yaml.lastIndexOf('\n', keySpanStart);
-
-      offset = prevNewLineIndex + 1;
-    }
-  }
-
-  formattedValue += valueString + lineEnding;
-
-  return SourceEdit(offset, 0, formattedValue);
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of adding
-/// the [key]:[newValue] pair when reparsed, bearing in mind that this is a flow
-/// map.
-SourceEdit _addToFlowMap(
-    YamlEditor yamlEdit, YamlMap map, YamlNode keyNode, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  final keyString = yamlEncodeFlowString(keyNode);
-  final valueString = yamlEncodeFlowString(newValue);
-
-  // The -1 accounts for the closing bracket.
-  if (map.isEmpty) {
-    return SourceEdit(map.span.end.offset - 1, 0, '$keyString: $valueString');
-  }
-
-  final insertionIndex = getMapInsertionIndex(map, keyString);
-
-  if (insertionIndex == map.length) {
-    return SourceEdit(map.span.end.offset - 1, 0, ', $keyString: $valueString');
-  }
-
-  final insertionOffset =
-      (map.nodes.keys.toList()[insertionIndex] as YamlNode).span.start.offset;
-
-  return SourceEdit(insertionOffset, 0, '$keyString: $valueString, ');
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of replacing
-/// the value at [key] with [newValue] when reparsed, bearing in mind that this
-/// is a block map.
-SourceEdit _replaceInBlockMap(
-    YamlEditor yamlEdit, YamlMap map, Object key, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  final yaml = yamlEdit.toString();
-  final lineEnding = getLineEnding(yaml);
-  final newIndentation =
-      getMapIndentation(yaml, map) + getIndentation(yamlEdit);
-
-  final keyNode = getKeyNode(map, key);
-  var valueAsString = yamlEncodeBlockString(
-      wrapAsYamlNode(newValue), newIndentation, lineEnding);
-  if (isCollection(newValue) &&
-      !isFlowYamlCollectionNode(newValue) &&
-      !isEmpty(newValue)) {
-    valueAsString = lineEnding + valueAsString;
-  }
-
-  /// +1 accounts for the colon
-  final start = keyNode.span.end.offset + 1;
-  var end = getContentSensitiveEnd(map.nodes[key]);
-
-  /// `package:yaml` parses empty nodes in a way where the start/end of the
-  /// empty value node is the end of the key node, so we have to adjust for
-  /// this.
-  if (end < start) end = start;
-
-  return SourceEdit(start, end - start, ' ' + valueAsString);
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of replacing
-/// the value at [key] with [newValue] when reparsed, bearing in mind that this
-/// is a flow map.
-SourceEdit _replaceInFlowMap(
-    YamlEditor yamlEdit, YamlMap map, Object key, YamlNode newValue) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-
-  final valueSpan = map.nodes[key].span;
-  final valueString = yamlEncodeFlowString(newValue);
-
-  return SourceEdit(valueSpan.start.offset, valueSpan.length, valueString);
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of removing
-/// the [key] from the map, bearing in mind that this is a block map.
-SourceEdit _removeFromBlockMap(
-    YamlEditor yamlEdit, YamlMap map, YamlNode keyNode, YamlNode valueNode) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-  ArgumentError.checkNotNull(keyNode, 'keyNode');
-  ArgumentError.checkNotNull(valueNode, 'valueNode');
-
-  final keySpan = keyNode.span;
-  var end = getContentSensitiveEnd(valueNode);
-  final yaml = yamlEdit.toString();
-
-  if (map.length == 1) {
-    final start = map.span.start.offset;
-    return SourceEdit(start, end - start, '{}');
-  }
-
-  var start = keySpan.start.offset;
-
-  /// Adjust the end to clear the new line after the end too.
-  ///
-  /// We do this because we suspect that our users will want the inline
-  /// comments to disappear too.
-  final nextNewLine = yaml.indexOf('\n', end);
-  if (nextNewLine != -1) {
-    end = nextNewLine + 1;
-  }
-
-  final nextNode = getNextKeyNode(map, keyNode);
-
-  if (start > 0) {
-    final lastHyphen = yaml.lastIndexOf('-', start - 1);
-    final lastNewLine = yaml.lastIndexOf('\n', start - 1);
-    if (lastHyphen > lastNewLine) {
-      start = lastHyphen + 2;
-
-      /// If there is a `-` before the node, and the end is on the same line
-      /// as the next node, we need to add the necessary offset to the end to
-      /// make sure the next node has the correct indentation.
-      if (nextNode != null &&
-          nextNode.span.start.offset - end <= nextNode.span.start.column) {
-        end += nextNode.span.start.column;
-      }
-    } else if (lastNewLine > lastHyphen) {
-      start = lastNewLine + 1;
-    }
-  }
-
-  return SourceEdit(start, end - start, '');
-}
-
-/// Performs the string operation on [yaml] to achieve the effect of removing
-/// the [key] from the map, bearing in mind that this is a flow map.
-SourceEdit _removeFromFlowMap(
-    YamlEditor yamlEdit, YamlMap map, YamlNode keyNode, YamlNode valueNode) {
-  ArgumentError.checkNotNull(yamlEdit, 'yamlEdit');
-  ArgumentError.checkNotNull(map, 'map');
-  ArgumentError.checkNotNull(keyNode, 'keyNode');
-  ArgumentError.checkNotNull(valueNode, 'valueNode');
-
-  var start = keyNode.span.start.offset;
-  var end = valueNode.span.end.offset;
-  final yaml = yamlEdit.toString();
-
-  if (deepEquals(keyNode, map.keys.first)) {
-    start = yaml.lastIndexOf('{', start - 1) + 1;
-
-    if (deepEquals(keyNode, map.keys.last)) {
-      end = yaml.indexOf('}', end);
-    } else {
-      end = yaml.indexOf(',', end) + 1;
-    }
-  } else {
-    start = yaml.lastIndexOf(',', start - 1);
-  }
-
-  return SourceEdit(start, end - start, '');
-}
diff --git a/lib/src/yaml_edit/source_edit.dart b/lib/src/yaml_edit/source_edit.dart
deleted file mode 100644
index 1b6512a..0000000
--- a/lib/src/yaml_edit/source_edit.dart
+++ /dev/null
@@ -1,145 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:meta/meta.dart';
-
-/// A class representing a change on a [String], intended to be compatible with
-/// `package:analysis_server`'s [SourceEdit].
-///
-/// For example, changing a string from
-/// ```
-/// foo: foobar
-/// ```
-/// to
-/// ```
-/// foo: barbar
-/// ```
-/// will be represented by `SourceEdit(offset: 4, length: 3, replacement: 'bar')`
-@sealed
-class SourceEdit {
-  /// The offset from the start of the string where the modification begins.
-  final int offset;
-
-  /// The length of the substring to be replaced.
-  final int length;
-
-  /// The replacement string to be used.
-  final String replacement;
-
-  /// Creates a new [SourceEdit] instance. [offset], [length] and [replacement]
-  /// must be non-null, and [offset] and [length] must be non-negative.
-  factory SourceEdit(int offset, int length, String replacement) =>
-      SourceEdit._(offset, length, replacement);
-
-  SourceEdit._(this.offset, this.length, this.replacement) {
-    ArgumentError.checkNotNull(offset, 'offset');
-    ArgumentError.checkNotNull(length, 'length');
-    ArgumentError.checkNotNull(replacement, 'replacement');
-    RangeError.checkNotNegative(offset);
-    RangeError.checkNotNegative(length);
-  }
-
-  @override
-  bool operator ==(Object other) {
-    if (other is SourceEdit) {
-      return offset == other.offset &&
-          length == other.length &&
-          replacement == other.replacement;
-    }
-
-    return false;
-  }
-
-  @override
-  int get hashCode => offset.hashCode ^ length.hashCode ^ replacement.hashCode;
-
-  /// Constructs a SourceEdit from JSON.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final edit = {
-  ///   'offset': 1,
-  ///   'length': 2,
-  ///   'replacement': 'replacement string'
-  /// };
-  ///
-  /// final sourceEdit = SourceEdit.fromJson(edit);
-  /// ```
-  factory SourceEdit.fromJson(Map<String, dynamic> json) {
-    ArgumentError.checkNotNull(json, 'json');
-
-    if (json is Map) {
-      final offset = json['offset'];
-      final length = json['length'];
-      final replacement = json['replacement'];
-
-      if (offset is int && length is int && replacement is String) {
-        return SourceEdit(offset, length, replacement);
-      }
-    }
-    throw FormatException('Invalid JSON passed to SourceEdit');
-  }
-
-  /// Encodes this object as JSON-compatible structure.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// import 'dart:convert' show jsonEncode;
-  ///
-  /// final edit = SourceEdit(offset, length, 'replacement string');
-  /// final jsonString = jsonEncode(edit.toJson());
-  /// print(jsonString);
-  /// ```
-  Map<String, dynamic> toJson() {
-    return {'offset': offset, 'length': length, 'replacement': replacement};
-  }
-
-  @override
-  String toString() => 'SourceEdit($offset, $length, "$replacement")';
-
-  /// Applies a series of [SourceEdit]s to an original string, and return the
-  /// final output.
-  ///
-  /// [edits] should be in order i.e. the first [SourceEdit] in [edits] should
-  /// be the first edit applied to [original].
-  ///
-  /// **Example:**
-  /// ```dart
-  /// const original = 'YAML: YAML';
-  /// final sourceEdits = [
-  ///        SourceEdit(6, 4, "YAML Ain't Markup Language"),
-  ///        SourceEdit(6, 4, "YAML Ain't Markup Language"),
-  ///        SourceEdit(0, 4, "YAML Ain't Markup Language")
-  ///      ];
-  /// final result = SourceEdit.applyAll(original, sourceEdits);
-  /// ```
-  /// **Expected result:**
-  /// ```dart
-  /// "YAML Ain't Markup Language: YAML Ain't Markup Language Ain't Markup
-  /// Language"
-  /// ```
-  static String applyAll(String original, Iterable<SourceEdit> edits) {
-    ArgumentError.checkNotNull(original, 'original');
-    ArgumentError.checkNotNull(edits, 'edits');
-
-    return edits.fold(original, (current, edit) => edit.apply(current));
-  }
-
-  /// Applies one [SourceEdit]s to an original string, and return the final
-  /// output.
-  ///
-  /// **Example:**
-  /// ```dart
-  /// final edit = SourceEdit(4, 3, 'bar');
-  /// final originalString = 'foo: foobar';
-  /// print(edit.apply(originalString)); // 'foo: barbar'
-  /// ```
-  String apply(String original) {
-    ArgumentError.checkNotNull(original, 'original');
-
-    return original.replaceRange(offset, offset + length, replacement);
-  }
-}
diff --git a/lib/src/yaml_edit/strings.dart b/lib/src/yaml_edit/strings.dart
deleted file mode 100644
index 8a7fee5..0000000
--- a/lib/src/yaml_edit/strings.dart
+++ /dev/null
@@ -1,315 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:yaml/yaml.dart';
-import 'utils.dart';
-
-/// Given [value], tries to format it into a plain string recognizable by YAML.
-/// If it fails, it defaults to returning a double-quoted string.
-///
-/// Not all values can be formatted into a plain string. If the string contains
-/// an escape sequence, it can only be detected when in a double-quoted
-/// sequence. Plain strings may also be misinterpreted by the YAML parser (e.g.
-/// ' null').
-String _tryYamlEncodePlain(Object value) {
-  if (value is YamlNode) {
-    AssertionError(
-        'YamlNodes should not be passed directly into getSafeString!');
-  }
-
-  assertValidScalar(value);
-
-  if (value is String) {
-    /// If it contains a dangerous character we want to wrap the result with
-    /// double quotes because the double quoted style allows for arbitrary
-    /// strings with "\" escape sequences.
-    ///
-    /// See 7.3.1 Double-Quoted Style
-    /// https://yaml.org/spec/1.2/spec.html#id2787109
-    if (isDangerousString(value)) {
-      return _yamlEncodeDoubleQuoted(value);
-    }
-
-    return value;
-  }
-
-  return value.toString();
-}
-
-/// Checks if [string] has unprintable characters according to
-/// [unprintableCharCodes].
-bool _hasUnprintableCharacters(String string) {
-  ArgumentError.checkNotNull(string, 'string');
-
-  final codeUnits = string.codeUnits;
-
-  for (final key in unprintableCharCodes.keys) {
-    if (codeUnits.contains(key)) return true;
-  }
-
-  return false;
-}
-
-/// Generates a YAML-safe double-quoted string based on [string], escaping the
-/// list of characters as defined by the YAML 1.2 spec.
-///
-/// See 5.7 Escaped Characters https://yaml.org/spec/1.2/spec.html#id2776092
-String _yamlEncodeDoubleQuoted(String string) {
-  ArgumentError.checkNotNull(string, 'string');
-
-  final buffer = StringBuffer();
-  for (final codeUnit in string.codeUnits) {
-    if (doubleQuoteEscapeChars[codeUnit] != null) {
-      buffer.write(doubleQuoteEscapeChars[codeUnit]);
-    } else {
-      buffer.writeCharCode(codeUnit);
-    }
-  }
-
-  return '"$buffer"';
-}
-
-/// Generates a YAML-safe single-quoted string. Automatically escapes
-/// single-quotes.
-///
-/// It is important that we ensure that [string] is free of unprintable
-/// characters by calling [assertValidScalar] before invoking this function.
-String _tryYamlEncodeSingleQuoted(String string) {
-  ArgumentError.checkNotNull(string, 'string');
-
-  final result = string.replaceAll('\'', '\'\'');
-  return '\'$result\'';
-}
-
-/// Generates a YAML-safe folded string.
-///
-/// It is important that we ensure that [string] is free of unprintable
-/// characters by calling [assertValidScalar] before invoking this function.
-String _tryYamlEncodeFolded(String string, int indentation, String lineEnding) {
-  ArgumentError.checkNotNull(string, 'string');
-  ArgumentError.checkNotNull(indentation, 'indentation');
-  ArgumentError.checkNotNull(lineEnding, 'lineEnding');
-
-  String result;
-
-  final trimmedString = string.trimRight();
-  final removedPortion = string.substring(trimmedString.length);
-
-  if (removedPortion.contains('\n')) {
-    result = '>+\n' + ' ' * indentation;
-  } else {
-    result = '>-\n' + ' ' * indentation;
-  }
-
-  /// Duplicating the newline for folded strings preserves it in YAML.
-  /// Assumes the user did not try to account for windows documents by using
-  /// `\r\n` already
-  return result +
-      trimmedString.replaceAll('\n', lineEnding * 2 + ' ' * indentation) +
-      removedPortion;
-}
-
-/// Generates a YAML-safe literal string.
-///
-/// It is important that we ensure that [string] is free of unprintable
-/// characters by calling [assertValidScalar] before invoking this function.
-String _tryYamlEncodeLiteral(
-    String string, int indentation, String lineEnding) {
-  ArgumentError.checkNotNull(string, 'string');
-  ArgumentError.checkNotNull(indentation, 'indentation');
-  ArgumentError.checkNotNull(lineEnding, 'lineEnding');
-
-  final result = '|-\n$string';
-
-  /// Assumes the user did not try to account for windows documents by using
-  /// `\r\n` already
-  return result.replaceAll('\n', lineEnding + ' ' * indentation);
-}
-
-/// Returns [value] with the necessary formatting applied in a flow context
-/// if possible.
-///
-/// If [value] is a [YamlScalar], we try to respect its [style] parameter where
-/// possible. Certain cases make this impossible (e.g. a plain string scalar that
-/// starts with '>'), in which case we will produce [value] with default styling
-/// options.
-String _yamlEncodeFlowScalar(YamlNode value) {
-  if (value is YamlScalar) {
-    assertValidScalar(value.value);
-
-    if (value.value is String) {
-      if (_hasUnprintableCharacters(value.value) ||
-          value.style == ScalarStyle.DOUBLE_QUOTED) {
-        return _yamlEncodeDoubleQuoted(value.value);
-      }
-
-      if (value.style == ScalarStyle.SINGLE_QUOTED) {
-        return _tryYamlEncodeSingleQuoted(value.value);
-      }
-    }
-
-    return _tryYamlEncodePlain(value.value);
-  }
-
-  assertValidScalar(value);
-  return _tryYamlEncodePlain(value);
-}
-
-/// Returns [value] with the necessary formatting applied in a block context
-/// if possible.
-///
-/// If [value] is a [YamlScalar], we try to respect its [style] parameter where
-/// possible. Certain cases make this impossible (e.g. a folded string scalar
-/// 'null'), in which case we will produce [value] with default styling
-/// options.
-String yamlEncodeBlockScalar(
-    YamlNode value, int indentation, String lineEnding) {
-  ArgumentError.checkNotNull(indentation, 'indentation');
-  ArgumentError.checkNotNull(lineEnding, 'lineEnding');
-
-  if (value is YamlScalar) {
-    assertValidScalar(value.value);
-
-    if (value.value is String) {
-      if (_hasUnprintableCharacters(value.value)) {
-        return _yamlEncodeDoubleQuoted(value.value);
-      }
-
-      if (value.style == ScalarStyle.SINGLE_QUOTED) {
-        return _tryYamlEncodeSingleQuoted(value.value);
-      }
-
-      // Strings with only white spaces will cause a misparsing
-      if (value.value.trim().length == value.value.length &&
-          value.value.length != 0) {
-        if (value.style == ScalarStyle.FOLDED) {
-          return _tryYamlEncodeFolded(value.value, indentation, lineEnding);
-        }
-
-        if (value.style == ScalarStyle.LITERAL) {
-          return _tryYamlEncodeLiteral(value.value, indentation, lineEnding);
-        }
-      }
-    }
-
-    return _tryYamlEncodePlain(value.value);
-  }
-
-  assertValidScalar(value);
-
-  /// The remainder of the possibilities are similar to how [getFlowScalar]
-  /// treats [value].
-  return _yamlEncodeFlowScalar(value);
-}
-
-/// Returns [value] with the necessary formatting applied in a flow context.
-///
-/// If [value] is a [YamlNode], we try to respect its [style] parameter where
-/// possible. Certain cases make this impossible (e.g. a plain string scalar
-/// that starts with '>', a child having a block style parameters), in which
-/// case we will produce [value] with default styling options.
-String yamlEncodeFlowString(YamlNode value) {
-  if (value is YamlList) {
-    final list = value.nodes;
-
-    final safeValues = list.map(yamlEncodeFlowString);
-    return '[' + safeValues.join(', ') + ']';
-  } else if (value is YamlMap) {
-    final safeEntries = value.nodes.entries.map((entry) {
-      final safeKey = yamlEncodeFlowString(entry.key);
-      final safeValue = yamlEncodeFlowString(entry.value);
-      return '$safeKey: $safeValue';
-    });
-
-    return '{' + safeEntries.join(', ') + '}';
-  }
-
-  return _yamlEncodeFlowScalar(value);
-}
-
-/// Returns [value] with the necessary formatting applied in a block context.
-///
-/// If [value] is a [YamlNode], we respect its [style] parameter.
-String yamlEncodeBlockString(
-    YamlNode value, int indentation, String lineEnding) {
-  ArgumentError.checkNotNull(indentation, 'indentation');
-  ArgumentError.checkNotNull(lineEnding, 'lineEnding');
-
-  const additionalIndentation = 2;
-
-  if (!isBlockNode(value)) return yamlEncodeFlowString(value);
-
-  final newIndentation = indentation + additionalIndentation;
-
-  if (value is YamlList) {
-    if (value.isEmpty) return ' ' * indentation + '[]';
-
-    Iterable<String> safeValues;
-
-    final children = value.nodes;
-
-    safeValues = children.map((child) {
-      var valueString =
-          yamlEncodeBlockString(child, newIndentation, lineEnding);
-      if (isCollection(child) && !isFlowYamlCollectionNode(child)) {
-        valueString = valueString.substring(newIndentation);
-      }
-
-      return ' ' * indentation + '- $valueString';
-    });
-
-    return safeValues.join(lineEnding);
-  } else if (value is YamlMap) {
-    if (value.isEmpty) return ' ' * indentation + '{}';
-
-    return value.nodes.entries.map((entry) {
-      final safeKey = yamlEncodeFlowString(entry.key);
-      final formattedKey = ' ' * indentation + safeKey;
-      final formattedValue =
-          yamlEncodeBlockString(entry.value, newIndentation, lineEnding);
-
-      /// Empty collections are always encoded in flow-style, so new-line must
-      /// be avoided.
-      if (isCollection(entry.value) && !isEmpty(entry.value)) {
-        return formattedKey + ':\n' + formattedValue;
-      }
-
-      return formattedKey + ': ' + formattedValue;
-    }).join(lineEnding);
-  }
-
-  return yamlEncodeBlockScalar(value, newIndentation, lineEnding);
-}
-
-/// List of unprintable characters.
-///
-/// See 5.7 Escape Characters https://yaml.org/spec/1.2/spec.html#id2776092
-final Map<int, String> unprintableCharCodes = {
-  0: '\\0', //  Escaped ASCII null (#x0) character.
-  7: '\\a', //  Escaped ASCII bell (#x7) character.
-  8: '\\b', //  Escaped ASCII backspace (#x8) character.
-  11: '\\v', // 	Escaped ASCII vertical tab (#xB) character.
-  12: '\\f', //  Escaped ASCII form feed (#xC) character.
-  13: '\\r', //  Escaped ASCII carriage return (#xD) character. Line Break.
-  27: '\\e', //  Escaped ASCII escape (#x1B) character.
-  133: '\\N', //  Escaped Unicode next line (#x85) character.
-  160: '\\_', //  Escaped Unicode non-breaking space (#xA0) character.
-  8232: '\\L', //  Escaped Unicode line separator (#x2028) character.
-  8233: '\\P', //  Escaped Unicode paragraph separator (#x2029) character.
-};
-
-/// List of escape characters. In particular, \x32 is not included because it
-/// can be processed normally.
-///
-/// See 5.7 Escape Characters https://yaml.org/spec/1.2/spec.html#id2776092
-final Map<int, String> doubleQuoteEscapeChars = {
-  ...unprintableCharCodes,
-  9: '\\t', //  Escaped ASCII horizontal tab (#x9) character. Printable
-  10: '\\n', //  Escaped ASCII line feed (#xA) character. Line Break.
-  34: '\\"', //  Escaped ASCII double quote (#x22).
-  47: '\\/', //  Escaped ASCII slash (#x2F), for JSON compatibility.
-  92: '\\\\', //  Escaped ASCII back slash (#x5C).
-};
diff --git a/lib/src/yaml_edit/utils.dart b/lib/src/yaml_edit/utils.dart
deleted file mode 100644
index 91ff530..0000000
--- a/lib/src/yaml_edit/utils.dart
+++ /dev/null
@@ -1,271 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'package:source_span/source_span.dart';
-import 'package:yaml/yaml.dart';
-
-import 'editor.dart';
-
-/// 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) {
-  ArgumentError.checkNotNull(string, 'string');
-
-  try {
-    if (loadYamlNode(string).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) {
-  ArgumentError.checkNotNull(node, '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) {
-  ArgumentError.checkNotNull(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) {
-  if (value is YamlList || value is YamlMap) {
-    return (value as dynamic).style == CollectionStyle.FLOW;
-  }
-
-  return false;
-}
-
-/// 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) {
-  ArgumentError.checkNotNull(map, 'map');
-
-  final keys = map.nodes.keys.map((k) => k.toString()).toList();
-
-  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) > 0);
-
-  if (insertionIndex != -1) return insertionIndex;
-
-  return map.length;
-}
-
-/// Returns the [style] property of [target], if it is a [YamlNode]. Otherwise return null.
-Object getStyle(Object target) {
-  if (target is YamlNode) {
-    return (target as dynamic).style;
-  }
-
-  return null;
-}
-
-/// Returns the detected indentation step used in [yaml], 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 [yaml].
-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) {
-  ArgumentError.checkNotNull(list, '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 lastNewLine = yaml.lastIndexOf('\n', lastSpanOffset - 1);
-  final lastHyphen = yaml.lastIndexOf('-', lastSpanOffset - 1);
-
-  if (lastNewLine == -1) return lastHyphen;
-
-  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) {
-  ArgumentError.checkNotNull(map, '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 stricly 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';
-}
diff --git a/lib/src/yaml_edit/wrap.dart b/lib/src/yaml_edit/wrap.dart
deleted file mode 100644
index a4e8975..0000000
--- a/lib/src/yaml_edit/wrap.dart
+++ /dev/null
@@ -1,187 +0,0 @@
-// 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.
-
-// @dart=2.10
-
-import 'dart:collection' as collection;
-import 'package:collection/collection.dart';
-import 'package:source_span/source_span.dart';
-import 'package:yaml/yaml.dart';
-
-import 'equality.dart';
-import 'utils.dart';
-
-/// Returns a new [YamlMap] constructed by applying [update] onto the [nodes]
-/// of this [YamlMap].
-YamlMap updatedYamlMap(YamlMap map, Function(Map) update) {
-  ArgumentError.checkNotNull(map, 'map');
-
-  final dummyMap = deepEqualsMap();
-  dummyMap.addAll(map.nodes);
-
-  update(dummyMap);
-
-  return wrapAsYamlNode(dummyMap);
-}
-
-/// Wraps [value] into a [YamlNode].
-///
-/// [Map]s, [List]s and Scalars will be wrapped as [YamlMap]s, [YamlList]s,
-/// and [YamlScalar]s respectively. If [collectionStyle]/[scalarStyle] is
-/// defined, and [value] is a collection or scalar, the wrapped [YamlNode] will
-/// have the respective style, otherwise it defaults to the ANY style.
-///
-/// If a [YamlNode] is passed in, no further wrapping will be done, and the
-/// [collectionStyle]/[scalarStyle] will not be applied.
-YamlNode wrapAsYamlNode(Object value,
-    {CollectionStyle collectionStyle = CollectionStyle.ANY,
-    ScalarStyle scalarStyle = ScalarStyle.ANY}) {
-  if (value is YamlScalar) {
-    assertValidScalar(value.value);
-    return value;
-  } else if (value is YamlList) {
-    for (final item in value.nodes) {
-      wrapAsYamlNode(item);
-    }
-
-    return value;
-  } else if (value is YamlMap) {
-    /// Both [entry.key] and [entry.values] are guaranteed to be [YamlNode]s,
-    /// so running this will just assert that they are valid scalars.
-    for (final entry in value.nodes.entries) {
-      wrapAsYamlNode(entry.key);
-      wrapAsYamlNode(entry.value);
-    }
-
-    return value;
-  } else if (value is Map) {
-    ArgumentError.checkNotNull(collectionStyle, 'collectionStyle');
-    return YamlMapWrap(value, collectionStyle: collectionStyle);
-  } else if (value is List) {
-    ArgumentError.checkNotNull(collectionStyle, 'collectionStyle');
-    return YamlListWrap(value, collectionStyle: collectionStyle);
-  } else {
-    assertValidScalar(value);
-
-    ArgumentError.checkNotNull(scalarStyle, 'scalarStyle');
-    return YamlScalarWrap(value, style: scalarStyle);
-  }
-}
-
-/// Internal class that allows us to define a constructor on [YamlScalar]
-/// which takes in [style] as an argument.
-class YamlScalarWrap implements YamlScalar {
-  /// The [ScalarStyle] to be used for the scalar.
-  @override
-  final ScalarStyle style;
-
-  @override
-  final SourceSpan span;
-
-  @override
-  final dynamic value;
-
-  YamlScalarWrap(this.value, {this.style = ScalarStyle.ANY, Object sourceUrl})
-      : span = shellSpan(sourceUrl) {
-    ArgumentError.checkNotNull(style, 'scalarStyle');
-  }
-
-  @override
-  String toString() => value.toString();
-}
-
-/// Internal class that allows us to define a constructor on [YamlMap]
-/// which takes in [style] as an argument.
-class YamlMapWrap
-    with collection.MapMixin, UnmodifiableMapMixin
-    implements YamlMap {
-  /// The [CollectionStyle] to be used for the map.
-  @override
-  final CollectionStyle style;
-
-  @override
-  final Map<dynamic, YamlNode> nodes;
-
-  @override
-  final SourceSpan span;
-
-  factory YamlMapWrap(Map dartMap,
-      {CollectionStyle collectionStyle = CollectionStyle.ANY,
-      Object sourceUrl}) {
-    ArgumentError.checkNotNull(collectionStyle, 'collectionStyle');
-
-    final wrappedMap = deepEqualsMap<dynamic, YamlNode>();
-
-    for (final entry in dartMap.entries) {
-      final wrappedKey = wrapAsYamlNode(entry.key);
-      final wrappedValue = wrapAsYamlNode(entry.value);
-      wrappedMap[wrappedKey] = wrappedValue;
-    }
-
-    return YamlMapWrap._(wrappedMap,
-        style: collectionStyle, sourceUrl: sourceUrl);
-  }
-
-  YamlMapWrap._(this.nodes,
-      {CollectionStyle style = CollectionStyle.ANY, Object sourceUrl})
-      : span = shellSpan(sourceUrl),
-        style = nodes.isEmpty ? CollectionStyle.FLOW : style;
-
-  @override
-  dynamic operator [](Object key) => nodes[key]?.value;
-
-  @override
-  Iterable get keys => nodes.keys.map((node) => node.value);
-
-  @override
-  Map get value => this;
-}
-
-/// Internal class that allows us to define a constructor on [YamlList]
-/// which takes in [style] as an argument.
-class YamlListWrap with collection.ListMixin implements YamlList {
-  /// The [CollectionStyle] to be used for the list.
-  @override
-  final CollectionStyle style;
-
-  @override
-  final List<YamlNode> nodes;
-
-  @override
-  final SourceSpan span;
-
-  @override
-  int get length => nodes.length;
-
-  @override
-  set length(int index) {
-    throw UnsupportedError('Cannot modify an unmodifiable List');
-  }
-
-  factory YamlListWrap(List dartList,
-      {CollectionStyle collectionStyle = CollectionStyle.ANY,
-      Object sourceUrl}) {
-    ArgumentError.checkNotNull(collectionStyle, 'collectionStyle');
-
-    final wrappedList = dartList.map(wrapAsYamlNode).toList();
-    return YamlListWrap._(wrappedList,
-        style: collectionStyle, sourceUrl: sourceUrl);
-  }
-
-  YamlListWrap._(this.nodes,
-      {CollectionStyle style = CollectionStyle.ANY, Object sourceUrl})
-      : span = shellSpan(sourceUrl),
-        style = nodes.isEmpty ? CollectionStyle.FLOW : style;
-
-  @override
-  dynamic operator [](int index) => nodes[index].value;
-
-  @override
-  operator []=(int index, value) {
-    throw UnsupportedError('Cannot modify an unmodifiable List');
-  }
-
-  @override
-  List get value => this;
-}
diff --git a/pubspec.yaml b/pubspec.yaml
index 5902f9d..23fc0c8 100644
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -25,6 +25,7 @@
   source_span: ^1.8.1
   stack_trace: ^1.10.0
   yaml: ^3.1.0
+  yaml_edit: ^2.0.0
 
 dev_dependencies:
   shelf_test_handler: ^2.0.0