repeatable 1.2.0 → 1.2.1

data/sorbet/rbi/gems/{diff-lcs@1.4.4.rbi → diff-lcs@1.6.2.rbi}

@@ -4,14 +4,62 @@
 # This is an autogenerated file for types exported from the `diff-lcs` gem.
 # Please instead update this file by running `bin/tapioca gem diff-lcs`.
 
+
 # source://diff-lcs//lib/diff/lcs.rb#3
 module Diff; end
 
+# == How Diff Works (by Mark-Jason Dominus)
+#
+# I once read an article written by the authors of +diff+; they said that they
+# hard worked very hard on the algorithm until they found the right one.
+#
+# I think what they ended up using (and I hope someone will correct me, because
+# I am not very confident about this) was the `longest common subsequence'
+# method. In the LCS problem, you have two sequences of items:
+#
+#    a b c d f g h j q z
+#    a b c d e f g i j k r x y z
+#
+# and you want to find the longest sequence of items that is present in both
+# original sequences in the same order. That is, you want to find a new
+# sequence *S* which can be obtained from the first sequence by deleting some
+# items, and from the second sequence by deleting other items. You also want
+# *S* to be as long as possible. In this case *S* is:
+#
+#    a b c d f g j z
+#
+# From there it's only a small step to get diff-like output:
+#
+#    e   h i   k   q r x y
+#    +   - +   +   - + + +
+#
+# This module solves the LCS problem. It also includes a canned function to
+# generate +diff+-like output.
+#
+# It might seem from the example above that the LCS of two sequences is always
+# pretty obvious, but that's not always the case, especially when the two
+# sequences have many repeated elements. For example, consider
+#
+#    a x b y c z p d q
+#    a b c a x b y c z
+#
+# A naive approach might start by matching up the +a+ and +b+ that appear at
+# the beginning of each sequence, like this:
+#
+#    a x b y c         z p d q
+#    a   b   c a b y c z
+#
+# This finds the common subsequence +a b c z+. But actually, the LCS is +a x b
+# y c z+:
+#
+#          a x b y c z p d q
+#    a b c a x b y c z
+#
 # source://diff-lcs//lib/diff/lcs.rb#51
 module Diff::LCS
   # Returns the difference set between +self+ and +other+. See Diff::LCS#diff.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#75
+  # source://diff-lcs//lib/diff/lcs.rb#76
   def diff(other, callbacks = T.unsafe(nil), &block); end
 
   # Returns an Array containing the longest common subsequence(s) between
@@ -20,80 +68,81 @@ module Diff::LCS
   #   lcs = seq1.lcs(seq2)
   #
   # A note when using objects: Diff::LCS only works properly when each object
-  # can be used as a key in a Hash, which typically means that the objects must
-  # implement Object#eql? in a way that two identical values compare
-  # identically for key purposes. That is:
+  # can be used as a key in a Hash. This means that those objects must implement
+  # the methods +#hash+ and +#eql?+ such that two objects containing identical values
+  # compare identically for key purposes. That is:
   #
-  #   O.new('a').eql?(O.new('a')) == true
+  #   O.new('a').eql?(O.new('a')) == true &&
+  #   O.new('a').hash == O.new('a').hash
   #
-  # source://diff-lcs//lib/diff/lcs.rb#70
+  # source://diff-lcs//lib/diff/lcs.rb#71
   def lcs(other, &block); end
 
   # Attempts to patch +self+ with the provided +patchset+. A new sequence based
   # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts
   # to autodiscover the direction of the patch.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#101
+  # source://diff-lcs//lib/diff/lcs.rb#102
   def patch(patchset); end
 
   # Attempts to patch +self+ with the provided +patchset+. A new sequence based
   # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Does no
   # patch direction autodiscovery.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#109
+  # source://diff-lcs//lib/diff/lcs.rb#110
   def patch!(patchset); end
 
   # Attempts to patch +self+ with the provided +patchset+, using #patch!. If
   # the sequence this is used on supports #replace, the value of +self+ will be
   # replaced. See Diff::LCS#patch. Does no patch direction autodiscovery.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#123
+  # source://diff-lcs//lib/diff/lcs.rb#124
   def patch_me(patchset); end
 
   # Returns the balanced ("side-by-side") difference set between +self+ and
   # +other+. See Diff::LCS#sdiff.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#81
+  # source://diff-lcs//lib/diff/lcs.rb#82
   def sdiff(other, callbacks = T.unsafe(nil), &block); end
 
   # Traverses the discovered longest common subsequences between +self+ and
   # +other+ using the alternate, balanced algorithm. See
   # Diff::LCS#traverse_balanced.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#94
+  # source://diff-lcs//lib/diff/lcs.rb#95
   def traverse_balanced(other, callbacks = T.unsafe(nil), &block); end
 
   # Traverses the discovered longest common subsequences between +self+ and
   # +other+. See Diff::LCS#traverse_sequences.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#87
+  # source://diff-lcs//lib/diff/lcs.rb#88
   def traverse_sequences(other, callbacks = T.unsafe(nil), &block); end
 
   # Attempts to patch +self+ with the provided +patchset+. A new sequence based
   # on +self+ and the +patchset+ will be created. See Diff::LCS#patch. Attempts
   # to autodiscover the direction of the patch.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#101
+  # source://diff-lcs//lib/diff/lcs.rb#102
   def unpatch(patchset); end
 
   # Attempts to unpatch +self+ with the provided +patchset+. A new sequence
   # based on +self+ and the +patchset+ will be created. See Diff::LCS#unpatch.
   # Does no patch direction autodiscovery.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#116
+  # source://diff-lcs//lib/diff/lcs.rb#117
   def unpatch!(patchset); end
 
   # Attempts to unpatch +self+ with the provided +patchset+, using #unpatch!.
   # If the sequence this is used on supports #replace, the value of +self+ will
   # be replaced. See Diff::LCS#unpatch. Does no patch direction autodiscovery.
   #
-  # source://diff-lcs//lib/diff/lcs.rb#134
+  # source://diff-lcs//lib/diff/lcs.rb#135
   def unpatch_me(patchset); end
 
   class << self
-    # :yields seq1[i] for each matched:
+    # :yields: seq1[i] for each matched
     #
-    # source://diff-lcs//lib/diff/lcs.rb#144
+    # source://diff-lcs//lib/diff/lcs.rb#145
     def LCS(seq1, seq2, &block); end
 
     # source://diff-lcs//lib/diff/lcs/callbacks.rb#52
@@ -109,12 +158,12 @@ module Diff::LCS
     # initialise it. If the +callbacks+ object (possibly initialised) responds to
     # #finish, it will be called.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#168
+    # source://diff-lcs//lib/diff/lcs.rb#169
     def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
 
-    # :yields seq1[i] for each matched:
+    # :yields: seq1[i] for each matched
     #
-    # source://diff-lcs//lib/diff/lcs.rb#144
+    # source://diff-lcs//lib/diff/lcs.rb#145
     def lcs(seq1, seq2, &block); end
 
     # Applies a +patchset+ to the sequence +src+ according to the +direction+
@@ -158,13 +207,13 @@ module Diff::LCS
     # representations of those objects. Prior to application, array
     # representations of Diff::LCS::Change objects will be reified.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#624
+    # source://diff-lcs//lib/diff/lcs.rb#627
     def patch(src, patchset, direction = T.unsafe(nil)); end
 
     # Given a set of patchset, convert the current version to the next version.
     # Does no auto-discovery.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#734
+    # source://diff-lcs//lib/diff/lcs.rb#737
     def patch!(src, patchset); end
 
     # #sdiff computes all necessary components to show two sequences and their
@@ -196,7 +245,7 @@ module Diff::LCS
     #     end
     #   end
     #
-    # source://diff-lcs//lib/diff/lcs.rb#200
+    # source://diff-lcs//lib/diff/lcs.rb#201
     def sdiff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
 
     # #traverse_balanced is an alternative to #traverse_sequences. It uses a
@@ -229,7 +278,7 @@ module Diff::LCS
     #                                 occurred.
     #
     # #traverse_balanced might be a bit slower than #traverse_sequences,
-    # noticable only while processing huge amounts of data.
+    # noticeable only while processing huge amounts of data.
     #
     # == Algorithm
     #
@@ -273,7 +322,7 @@ module Diff::LCS
     # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>,
     # <tt>callbacks#discard_b</tt>, and <tt>callbacks#change</tt> are invoked
     # with an event comprising the action ("=", "+", "-", or "!", respectively),
-    # the indicies +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
+    # the indexes +i+ and +j+, and the elements <tt>A[i]</tt> and <tt>B[j]</tt>.
     # Return values are discarded by #traverse_balanced.
     #
     # === Context
@@ -281,7 +330,7 @@ module Diff::LCS
     # Note that +i+ and +j+ may not be the same index position, even if +a+ and
     # +b+ are considered to be pointing to matching or changed elements.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#475
+    # source://diff-lcs//lib/diff/lcs.rb#476
     def traverse_balanced(seq1, seq2, callbacks = T.unsafe(nil)); end
 
     # #traverse_sequences is the most general facility provided by this module;
@@ -333,12 +382,13 @@ module Diff::LCS
     # advance that arrow and will call <tt>callbacks#discard_a</tt> or
     # <tt>callbacks#discard_b</tt>, depending on which arrow it advanced. If both
     # arrows point to elements that are not part of the longest common
-    # subsequence, then #traverse_sequences will advance one of them and call the
-    # appropriate callback, but it is not specified which it will call.
+    # subsequence, then #traverse_sequences will advance arrow +a+ and call the
+    # appropriate callback, then it will advance arrow +b+ and call the appropriate
+    # callback.
     #
     # The methods for <tt>callbacks#match</tt>, <tt>callbacks#discard_a</tt>, and
     # <tt>callbacks#discard_b</tt> are invoked with an event comprising the
-    # action ("=", "+", or "-", respectively), the indicies +i+ and +j+, and the
+    # action ("=", "+", or "-", respectively), the indexes +i+ and +j+, and the
     # elements <tt>A[i]</tt> and <tt>B[j]</tt>. Return values are discarded by
     # #traverse_sequences.
     #
@@ -365,13 +415,13 @@ module Diff::LCS
     # is reached, if +a+ has not yet reached the end of +A+ or +b+ has not yet
     # reached the end of +B+.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#284
+    # source://diff-lcs//lib/diff/lcs.rb#286
     def traverse_sequences(seq1, seq2, callbacks = T.unsafe(nil)); end
 
     # Given a set of patchset, convert the current version to the prior version.
     # Does no auto-discovery.
     #
-    # source://diff-lcs//lib/diff/lcs.rb#728
+    # source://diff-lcs//lib/diff/lcs.rb#731
     def unpatch!(src, patchset); end
 
     private
@@ -506,6 +556,8 @@ class Diff::LCS::Change
   end
 end
 
+# Fixnum is deprecated in Ruby 2.4 # standard:disable Naming/ConstantName
+#
 # source://diff-lcs//lib/diff/lcs/change.rb#7
 Diff::LCS::Change::IntClass = Integer
 
@@ -648,15 +700,15 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.map { |f| f.to_a } }
 #
-# source://diff-lcs//lib/diff/lcs/callbacks.rb#223
+# source://diff-lcs//lib/diff/lcs/callbacks.rb#225
 class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#232
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#234
   def change(event); end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#224
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#226
   def discard_a(event); end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#228
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#230
   def discard_b(event); end
 end
 
@@ -748,38 +800,38 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.map { |f| f.to_a } }
 #
-# source://diff-lcs//lib/diff/lcs/callbacks.rb#106
+# source://diff-lcs//lib/diff/lcs/callbacks.rb#108
 class Diff::LCS::DiffCallbacks
-  # :yields self:
+  # :yields: self
   #
   # @return [DiffCallbacks] a new instance of DiffCallbacks
   #
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#110
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#112
   def initialize; end
 
   # Returns the difference set collected during the diff process.
   #
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#108
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#110
   def diffs; end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#133
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#135
   def discard_a(event); end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#137
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#139
   def discard_b(event); end
 
   # Finalizes the diff process. If an unprocessed hunk still exists, then it
   # is appended to the diff list.
   #
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#125
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#127
   def finish; end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#129
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#131
   def match(_event); end
 
   private
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#141
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#143
   def finish_hunk; end
 end
 
@@ -799,48 +851,48 @@ class Diff::LCS::Hunk
 
   # Returns the value of attribute blocks.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#63
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#64
   def blocks; end
 
   # Returns a diff string based on a format.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#116
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#115
   def diff(format, last = T.unsafe(nil)); end
 
   # Returns the value of attribute end_new.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#65
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#66
   def end_new; end
 
   # Returns the value of attribute end_old.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#65
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#66
   def end_old; end
 
   # Returns the value of attribute file_length_difference.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#66
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#67
   def file_length_difference; end
 
   # Change the "start" and "end" fields to note that context should be added
   # to this hunk.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#70
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#71
   def flag_context; end
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#72
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#73
   def flag_context=(context); end
 
   # Merges this hunk and the provided hunk together if they overlap. Returns
   # a truthy value so that if there is no overlap, you can know the merge
   # was skipped.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#98
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#97
   def merge(hunk); end
 
   # @return [Boolean]
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#326
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#347
   def missing_last_newline?(data); end
 
   # Determines whether there is an overlap between this hunk and the
@@ -849,61 +901,61 @@ class Diff::LCS::Hunk
   #
   # @return [Boolean]
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#110
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#109
   def overlaps?(hunk); end
 
   # Returns the value of attribute start_new.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#64
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#65
   def start_new; end
 
   # Returns the value of attribute start_old.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#64
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#65
   def start_old; end
 
   # Merges this hunk and the provided hunk together if they overlap. Returns
   # a truthy value so that if there is no overlap, you can know the merge
   # was skipped.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#98
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#97
   def unshift(hunk); end
 
   private
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#213
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#222
   def context_diff(last = T.unsafe(nil)); end
 
   # Generate a range of item numbers to print. Only print 1 number if the
   # range has only one item in it. Otherwise, it's 'start,end'
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#293
-  def context_range(mode, op, last = T.unsafe(nil)); end
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#316
+  def context_range(mode, op); end
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#271
-  def ed_diff(format, _last = T.unsafe(nil)); end
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#284
+  def ed_diff(format, last); end
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#339
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#360
   def encode(literal, target_encoding = T.unsafe(nil)); end
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#343
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#364
   def encode_as(string, *args); end
 
   # Note that an old diff can't have any context. Therefore, we know that
   # there's only one block in the hunk.
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#135
-  def old_diff(_last = T.unsafe(nil)); end
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#134
+  def old_diff(last = T.unsafe(nil)); end
 
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#160
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#167
   def unified_diff(last = T.unsafe(nil)); end
 
   # Generate a range of item numbers to print for unified diff. Print number
   # where block starts, followed by number of lines in the block
   # (don't print number of lines if it's 1)
   #
-  # source://diff-lcs//lib/diff/lcs/hunk.rb#311
-  def unified_range(mode, last); end
+  # source://diff-lcs//lib/diff/lcs/hunk.rb#331
+  def unified_range(mode); end
 end
 
 # source://diff-lcs//lib/diff/lcs/hunk.rb#10
@@ -920,7 +972,7 @@ module Diff::LCS::Internals
     # the object form of same) and detection of whether the patchset represents
     # changes to be made.
     #
-    # source://diff-lcs//lib/diff/lcs/internals.rb#98
+    # source://diff-lcs//lib/diff/lcs/internals.rb#102
     def analyze_patchset(patchset, depth = T.unsafe(nil)); end
 
     # Examine the patchset and the source to see in which direction the
@@ -931,7 +983,7 @@ module Diff::LCS::Internals
     # Diff::LCS::Change as its source, as an array will cause the creation
     # of one of the above.
     #
-    # source://diff-lcs//lib/diff/lcs/internals.rb#143
+    # source://diff-lcs//lib/diff/lcs/internals.rb#147
     def intuit_diff_direction(src, patchset, limit = T.unsafe(nil)); end
 
     # Compute the longest common subsequence between the sequenced
@@ -952,14 +1004,14 @@ module Diff::LCS::Internals
     # Enumerable, compute the inverse of +vector+ that maps this Enumerable
     # onto the collection. (Currently unused.)
     #
-    # source://diff-lcs//lib/diff/lcs/internals.rb#282
+    # source://diff-lcs//lib/diff/lcs/internals.rb#286
     def inverse_vector(a, vector); end
 
     # Returns a hash mapping each element of an Enumerable to the set of
     # positions it occupies in the Enumerable, optionally restricted to the
     # elements specified in the range of indexes specified by +interval+.
     #
-    # source://diff-lcs//lib/diff/lcs/internals.rb#294
+    # source://diff-lcs//lib/diff/lcs/internals.rb#298
     def position_hash(enum, interval); end
 
     # Find the place at which +value+ would normally be inserted into the
@@ -971,7 +1023,7 @@ module Diff::LCS::Internals
     #
     # This operation preserves the sort order.
     #
-    # source://diff-lcs//lib/diff/lcs/internals.rb#248
+    # source://diff-lcs//lib/diff/lcs/internals.rb#252
     def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
   end
 end
@@ -1041,32 +1093,32 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.to_a }
 #
-# source://diff-lcs//lib/diff/lcs/callbacks.rb#301
+# source://diff-lcs//lib/diff/lcs/callbacks.rb#303
 class Diff::LCS::SDiffCallbacks
-  # :yields self:
+  # :yields: self
   #
   # @return [SDiffCallbacks] a new instance of SDiffCallbacks
   # @yield [_self]
   # @yieldparam _self [Diff::LCS::SDiffCallbacks] the object that the method was called on
   #
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#305
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#307
   def initialize; end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#322
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#324
   def change(event); end
 
   # Returns the difference set collected during the diff process.
   #
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#303
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#305
   def diffs; end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#314
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#316
   def discard_a(event); end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#318
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#320
   def discard_b(event); end
 
-  # source://diff-lcs//lib/diff/lcs/callbacks.rb#310
+  # source://diff-lcs//lib/diff/lcs/callbacks.rb#312
   def match(event); end
 end
 
@@ -1078,5 +1130,5 @@ end
 # source://diff-lcs//lib/diff/lcs/callbacks.rb#44
 Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks
 
-# source://diff-lcs//lib/diff/lcs.rb#52
+# source://diff-lcs//lib/diff/lcs/version.rb#5
 Diff::LCS::VERSION = T.let(T.unsafe(nil), String)