m2m_keygen 0.4.9 → 0.5.1

data/sorbet/rbi/gems/{diff-lcs@1.5.0.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-1.5.0/lib/diff/lcs.rb:3
+
+# pkg:gem/diff-lcs#lib/diff/lcs.rb:3
 module Diff; end
 
-# source://diff-lcs-1.5.0/lib/diff/lcs.rb:51
+# == 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
+#
+# pkg:gem/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-1.5.0/lib/diff/lcs.rb:75
+  # pkg:gem/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,83 +68,78 @@ 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-1.5.0/lib/diff/lcs.rb:70
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:101
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:109
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:123
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:81
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:94
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:87
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:101
+  # pkg:gem/diff-lcs#lib/diff/lcs.rb:105
   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-1.5.0/lib/diff/lcs.rb:116
+  # pkg:gem/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-1.5.0/lib/diff/lcs.rb:134
+  # pkg:gem/diff-lcs#lib/diff/lcs.rb:135
   def unpatch_me(patchset); end
 
   class << self
-    # :yields seq1[i] for each matched:
-    #
-    # source://diff-lcs-1.5.0/lib/diff/lcs.rb:144
+    # pkg:gem/diff-lcs#lib/diff/lcs.rb:158
     def LCS(seq1, seq2, &block); end
 
-    # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:52
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:52
     def callbacks_for(callbacks); end
 
     # #diff computes the smallest set of additions and deletions necessary to
@@ -109,12 +152,10 @@ module Diff::LCS
     # initialise it. If the +callbacks+ object (possibly initialised) responds to
     # #finish, it will be called.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs.rb:168
+    # pkg:gem/diff-lcs#lib/diff/lcs.rb:169
     def diff(seq1, seq2, callbacks = T.unsafe(nil), &block); end
 
-    # :yields seq1[i] for each matched:
-    #
-    # source://diff-lcs-1.5.0/lib/diff/lcs.rb:144
+    # pkg:gem/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 +199,13 @@ module Diff::LCS
     # representations of those objects. Prior to application, array
     # representations of Diff::LCS::Change objects will be reified.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs.rb:624
+    # pkg:gem/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-1.5.0/lib/diff/lcs.rb:734
+    # pkg:gem/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 +237,7 @@ module Diff::LCS
     #     end
     #   end
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs.rb:200
+    # pkg:gem/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 +270,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 +314,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 +322,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-1.5.0/lib/diff/lcs.rb:475
+    # pkg:gem/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;
@@ -339,7 +380,7 @@ module Diff::LCS
     #
     # 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.
     #
@@ -366,18 +407,18 @@ 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-1.5.0/lib/diff/lcs.rb:285
+    # pkg:gem/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-1.5.0/lib/diff/lcs.rb:728
+    # pkg:gem/diff-lcs#lib/diff/lcs.rb:731
     def unpatch!(src, patchset); end
 
     private
 
-    # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:4
+    # pkg:gem/diff-lcs#lib/diff/lcs/internals.rb:4
     def diff_traversal(method, seq1, seq2, callbacks, &block); end
   end
 end
@@ -387,39 +428,31 @@ end
 #
 #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::BalancedCallbacks)
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:50
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:50
 Diff::LCS::BalancedCallbacks = Diff::LCS::DefaultCallbacks
 
 # A block is an operation removing, adding, or changing a group of items.
 # Basically, this is just a list of changes, where each change adds or
 # deletes a single item. Used by bin/ldiff.
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:6
+# pkg:gem/diff-lcs#lib/diff/lcs/block.rb:6
 class Diff::LCS::Block
-  # @return [Block] a new instance of Block
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:9
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:9
   def initialize(chunk); end
 
-  # Returns the value of attribute changes.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:7
   def changes; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:21
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:21
   def diff_size; end
 
-  # Returns the value of attribute insert.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:7
   def insert; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:25
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:25
   def op; end
 
-  # Returns the value of attribute remove.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/block.rb:7
+  # pkg:gem/diff-lcs#lib/diff/lcs/block.rb:7
   def remove; end
 end
 
@@ -427,87 +460,71 @@ end
 # addition of an element from either the old or the new sequenced
 # enumerable.
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:6
+# pkg:gem/diff-lcs#lib/diff/lcs/change.rb:6
 class Diff::LCS::Change
   include ::Comparable
 
-  # @return [Change] a new instance of Change
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:27
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:27
   def initialize(*args); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:65
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:65
   def <=>(other); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:58
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:58
   def ==(other); end
 
   # Returns the action this Change represents.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:20
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:20
   def action; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:72
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:72
   def adding?; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:84
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:84
   def changed?; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:76
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:76
   def deleting?; end
 
   # Returns the sequence element of the Change.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:25
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:25
   def element; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:88
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:88
   def finished_a?; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:92
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:92
   def finished_b?; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:34
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:34
   def inspect(*_args); end
 
   # Returns the position of the Change.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:23
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:23
   def position; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:38
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:38
   def to_a; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:38
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:42
   def to_ary; end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:80
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:80
   def unchanged?; end
 
   class << self
-    # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:44
+    # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:44
     def from_a(arr); end
 
-    # @return [Boolean]
-    #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:15
+    # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:15
     def valid_action?(action); end
   end
 end
 
-# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:7
+# pkg:gem/diff-lcs#lib/diff/lcs/change.rb:7
 Diff::LCS::Change::IntClass = Integer
 
 # The only actions valid for changes are '+' (add), '-' (delete), '='
@@ -515,60 +532,58 @@ Diff::LCS::Change::IntClass = Integer
 # '>' (tail changes from second sequence). The last two ('<>') are only
 # found with Diff::LCS::diff and Diff::LCS::sdiff.
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:13
+# pkg:gem/diff-lcs#lib/diff/lcs/change.rb:13
 Diff::LCS::Change::VALID_ACTIONS = T.let(T.unsafe(nil), Array)
 
 # Represents a contextual change. Contains the position and values of the
 # elements in the old and the new sequenced enumerables as well as the action
 # taken.
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:101
+# pkg:gem/diff-lcs#lib/diff/lcs/change.rb:100
 class Diff::LCS::ContextChange < ::Diff::LCS::Change
-  # @return [ContextChange] a new instance of ContextChange
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:114
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:114
   def initialize(*args); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:166
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:166
   def <=>(other); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:157
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:157
   def ==(other); end
 
   # Returns the new element being changed.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:112
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:112
   def new_element; end
 
   # Returns the new position being changed.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:108
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:108
   def new_position; end
 
   # Returns the old element being changed.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:110
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:110
   def old_element; end
 
   # Returns the old position being changed.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:106
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:106
   def old_position; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:122
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:122
   def to_a; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:122
+  # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:130
   def to_ary; end
 
   class << self
-    # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:132
+    # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:132
     def from_a(arr); end
 
     # Simplifies a context change for use in some diff callbacks. '<' actions
     # are converted to '-' and '>' actions are converted to '+'.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/change.rb:138
+    # pkg:gem/diff-lcs#lib/diff/lcs/change.rb:138
     def simplify(event); end
   end
 end
@@ -649,15 +664,15 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.map { |f| f.to_a } }
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:223
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:225
 class Diff::LCS::ContextDiffCallbacks < ::Diff::LCS::DiffCallbacks
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:232
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:234
   def change(event); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:224
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:226
   def discard_a(event); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:228
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:230
   def discard_b(event); end
 end
 
@@ -670,28 +685,33 @@ end
 #
 #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::DefaultCallbacks)
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:14
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:14
 class Diff::LCS::DefaultCallbacks
   class << self
     # Called when both the old and new values have changed.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:32
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:32
     def change(event); end
 
     # Called when the old value is discarded in favour of the new value.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:22
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:22
     def discard_a(event); end
 
     # Called when the new value is discarded in favour of the old value.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:27
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:27
     def discard_b(event); end
 
     # Called when two items match.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:17
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:17
     def match(event); end
+
+    private
+
+    # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:36
+    def new(*_arg0); end
   end
 end
 
@@ -745,38 +765,34 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.map { |f| f.to_a } }
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:106
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:108
 class Diff::LCS::DiffCallbacks
-  # :yields self:
-  #
-  # @return [DiffCallbacks] a new instance of DiffCallbacks
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:110
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:112
   def initialize; end
 
   # Returns the difference set collected during the diff process.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:108
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:110
   def diffs; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:133
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:135
   def discard_a(event); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:137
+  # pkg:gem/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-1.5.0/lib/diff/lcs/callbacks.rb:125
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:127
   def finish; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:129
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:131
   def match(_event); end
 
   private
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:141
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:143
   def finish_hunk; end
 end
 
@@ -784,132 +800,110 @@ end
 # each block. (So if we're not using context, every hunk will contain one
 # block.) Used in the diff program (bin/ldiff).
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:8
+# pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:8
 class Diff::LCS::Hunk
   # Create a hunk using references to both the old and new data, as well as the
   # piece of data.
   #
-  # @return [Hunk] a new instance of Hunk
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:16
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:16
   def initialize(data_old, data_new, piece, flag_context, file_length_difference); end
 
-  # Returns the value of attribute blocks.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:63
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:64
   def blocks; end
 
   # Returns a diff string based on a format.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:116
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:65
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:66
   def end_new; end
 
-  # Returns the value of attribute end_old.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:65
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:66
   def end_old; end
 
-  # Returns the value of attribute file_length_difference.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:66
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:70
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:71
   def flag_context; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:72
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:71
   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-1.5.0/lib/diff/lcs/hunk.rb:98
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:97
   def merge(hunk); end
 
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:326
+  # pkg:gem/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
   # provided hunk. This will be true if the difference between the two hunks
   # start or end positions is within one position of each other.
   #
-  # @return [Boolean]
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:110
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:109
   def overlaps?(hunk); end
 
-  # Returns the value of attribute start_new.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:64
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:65
   def start_new; end
 
-  # Returns the value of attribute start_old.
-  #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:64
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:98
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:104
   def unshift(hunk); end
 
   private
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:213
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:293
-  def context_range(mode, op, last = T.unsafe(nil)); end
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:316
+  def context_range(mode, op); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:271
-  def ed_diff(format, _last = T.unsafe(nil)); end
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:284
+  def ed_diff(format, last); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:339
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:360
   def encode(literal, target_encoding = T.unsafe(nil)); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:343
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:135
-  def old_diff(_last = T.unsafe(nil)); end
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:134
+  def old_diff(last = T.unsafe(nil)); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:160
+  # pkg:gem/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-1.5.0/lib/diff/lcs/hunk.rb:311
-  def unified_range(mode, last); end
+  # pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:331
+  def unified_range(mode); end
 end
 
-# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:10
+# pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:10
 Diff::LCS::Hunk::ED_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)
 
-# source://diff-lcs-1.5.0/lib/diff/lcs/hunk.rb:9
+# pkg:gem/diff-lcs#lib/diff/lcs/hunk.rb:9
 Diff::LCS::Hunk::OLD_DIFF_OP_ACTION = T.let(T.unsafe(nil), Hash)
 
-# source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:29
+# pkg:gem/diff-lcs#lib/diff/lcs/internals.rb:29
 module Diff::LCS::Internals
   class << self
     # This method will analyze the provided patchset to provide a single-pass
@@ -917,7 +911,7 @@ module Diff::LCS::Internals
     # the object form of same) and detection of whether the patchset represents
     # changes to be made.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:102
+    # pkg:gem/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
@@ -928,7 +922,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-1.5.0/lib/diff/lcs/internals.rb:147
+    # pkg:gem/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
@@ -940,7 +934,7 @@ module Diff::LCS::Internals
     #       assert_equal(a[i], b[e]) unless e.nil?
     #     end
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:41
+    # pkg:gem/diff-lcs#lib/diff/lcs/internals.rb:41
     def lcs(a, b); end
 
     private
@@ -949,14 +943,14 @@ module Diff::LCS::Internals
     # Enumerable, compute the inverse of +vector+ that maps this Enumerable
     # onto the collection. (Currently unused.)
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:286
+    # pkg:gem/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-1.5.0/lib/diff/lcs/internals.rb:298
+    # pkg:gem/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
@@ -968,7 +962,7 @@ module Diff::LCS::Internals
     #
     # This operation preserves the sort order.
     #
-    # source://diff-lcs-1.5.0/lib/diff/lcs/internals.rb:252
+    # pkg:gem/diff-lcs#lib/diff/lcs/internals.rb:252
     def replace_next_larger(enum, value, last_index = T.unsafe(nil)); end
   end
 end
@@ -1038,32 +1032,26 @@ end
 #     require 'pp'
 #     pp diffs.map { |e| e.to_a }
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:301
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:303
 class Diff::LCS::SDiffCallbacks
-  # :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-1.5.0/lib/diff/lcs/callbacks.rb:305
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:307
   def initialize; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:322
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:324
   def change(event); end
 
   # Returns the difference set collected during the diff process.
   #
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:303
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:305
   def diffs; end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:314
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:316
   def discard_a(event); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:318
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:320
   def discard_b(event); end
 
-  # source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:310
+  # pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:312
   def match(event); end
 end
 
@@ -1072,8 +1060,10 @@ end
 #
 #     Diff::LCS.LCS(seq1, seq2, Diff::LCS::SequenceCallbacks)
 #
-# source://diff-lcs-1.5.0/lib/diff/lcs/callbacks.rb:44
+# pkg:gem/diff-lcs#lib/diff/lcs/callbacks.rb:44
 Diff::LCS::SequenceCallbacks = Diff::LCS::DefaultCallbacks
 
-# source://diff-lcs-1.5.0/lib/diff/lcs.rb:52
+# pkg:gem/diff-lcs#lib/diff/lcs/version.rb:5
 Diff::LCS::VERSION = T.let(T.unsafe(nil), String)
+
+Integer::GMP_VERSION = T.let(T.unsafe(nil), String)