Add bin and edit workflow

bin/gems/set-1.1.1/.github/CODEOWNERS

@@ -0,0 +1 @@
+* @knu

bin/gems/set-1.1.1/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

bin/gems/set-1.1.1/.github/workflows/test.yml

@@ -0,0 +1,29 @@
+name: test
+
+on: [push, pull_request]
+
+jobs:
+  ruby-versions:
+    uses: ruby/actions/.github/workflows/ruby_versions.yml@master
+    with:
+      engine: cruby
+      min_version: 3.0
+
+  build:
+    needs: ruby-versions
+    name: build (${{ matrix.ruby }} / ${{ matrix.os }})
+    strategy:
+      matrix:
+        ruby: ${{ fromJson(needs.ruby-versions.outputs.versions) }}
+        os: [ ubuntu-latest, macos-latest ]
+    runs-on: ${{ matrix.os }}
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - name: Install dependencies
+      run: bundle install
+    - name: Run test
+      run: rake test

bin/gems/set-1.1.1/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock

bin/gems/set-1.1.1/CHANGELOG.md

@@ -0,0 +1,68 @@
+# Set Changelog
+
+# 1.1.1 (2024-11-29)
+
+* Enhancements
+  * Fix Set#^ to respect subclasses [#38][] ([@kyanagi][])
+  * Speed up Set#flatten [#39][] ([@kyanagi][])
+
+# 1.1.0 (2023-12-23)
+
+* Optimize for and require Ruby >=3
+
+# 1.0.4 (2023-12-08)
+
+* Enhancements
+  * Avoid the `block or return` pattern to save Proc allocations [#29][] ([@casperisfine][])
+  * Set#merge takes many enumerable objects [#30][]
+
+# 1.0.3 (2022-09-06)
+
+* Enhancements
+  * Make Set a builtin feature \[[Feature #16989][]]
+
+# 1.0.2 (2021-10-25)
+
+* Enhancements
+  * Allow Set#intersect? and #disjoint? to accept array argument \[[Feature #17838][]] [#18][] ([@jeremyevans][])
+  * Make Set#pretty_print IRB::ColorPrinter friendly [#17][] ([@k-tsj][])
+  * Improve documentation [#16][], [#20][] ([@BurdetteLamar][])
+  * Follow the license change in Ruby and add BSD-2-Clause
+
+# 1.0.1 (2020-12-22)
+
+* Enhancements
+  * Eliminate warnings
+
+# 1.0.0 (2020-12-21)
+
+This is the first release of set as a gem.  Here lists the changes since the version bundled with Ruby 2.7.
+
+* Breaking Changes
+  * SortedSet has been removed for dependency and performance reasons. [#2][] ([@knu][])
+
+* Enhancements
+  * Set#join is added as a shorthand for `.to_a.join`. [#4][] ([@marcandre][])
+  * Set#<=> is added. [#5][] ([@marcandre][])
+
+[#2]: https://github.com/ruby/set/pull/2
+[#4]: https://github.com/ruby/set/pull/4
+[#5]: https://github.com/ruby/set/pull/5
+[#16]: https://github.com/ruby/set/pull/16
+[#17]: https://github.com/ruby/set/pull/17
+[#18]: https://github.com/ruby/set/pull/18
+[#20]: https://github.com/ruby/set/pull/20
+[#29]: https://github.com/ruby/set/pull/29
+[#30]: https://github.com/ruby/set/pull/30
+[#38]: https://github.com/ruby/set/pull/38
+[#39]: https://github.com/ruby/set/pull/39
+[Feature #17838]: https://bugs.ruby-lang.org/issues/17838
+[Feature #16989]: https://bugs.ruby-lang.org/issues/16989
+
+[@BurdetteLamar]: https://github.com/BurdetteLamar
+[@casperisfine]: https://github.com/casperisfine
+[@jeremyevans]: https://github.com/jeremyevans
+[@k-tsj]: https://github.com/k-tsj
+[@knu]: https://github.com/knu
+[@kyanagi]: https://github.com/kyanagi
+[@marcandre]: https://github.com/marcandre

bin/gems/set-1.1.1/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in set.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"
+gem "test-unit"

bin/gems/set-1.1.1/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2002-2024 Akinori MUSHA
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

bin/gems/set-1.1.1/README.md

@@ -0,0 +1,79 @@
+# Set
+
+This library provides the Set class, which deals with a collection of
+unordered values with no duplicates.  It is a hybrid of Array's
+intuitive inter-operation facilities and Hash's fast lookup.
+
+The method `to_set` is added to Enumerable for convenience.
+
+Set implements a collection of unordered values with no duplicates.
+This is a hybrid of Array's intuitive inter-operation facilities and
+Hash's fast lookup.
+
+Set is easy to use with Enumerable objects (implementing `each`).
+Most of the initializer methods and binary operators accept generic
+Enumerable objects besides sets and arrays.  An Enumerable object can
+be converted to Set using the `to_set` method.
+
+Set uses Hash as storage, so you must note the following points:
+
+* Equality of elements is determined according to Object#eql? and
+  Object#hash.  Use Set#compare_by_identity to make a set compare its
+  elements by their identity.
+
+* Set assumes that the identity of each element does not change while
+  it is stored.  Modifying an element of a set will render the set to
+  an unreliable state.
+
+* When a string is to be stored, a frozen copy of the string is stored
+  instead unless the original string is already frozen.
+
+### Comparison
+
+The comparison operators `<`, `>`, `<=`, and `>=` are implemented as
+shorthand for the {proper_,}{subset?,superset?} methods.  The `<=>`
+operator reflects this order, or return `nil` for sets that both have
+distinct elements (`{x, y}` vs. `{x, z}` for example).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'set'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install set
+
+## Usage
+
+```ruby
+require 'set'
+s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
+s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
+s1 == s2                              #=> true
+s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
+s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
+s1.subset?(s2)                        #=> false
+s2.subset?(s1)                        #=> true
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/set.
+
+Feature requests should also go to https://bugs.ruby-lang.org/ for wider audience and discussion.
+
+## License
+
+The gem is available as open source under either the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).  When bundled with Ruby, you can distribute/modify this program under the same terms of [Ruby](https://www.ruby-lang.org/en/about/license.txt).

bin/gems/set-1.1.1/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

bin/gems/set-1.1.1/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "set"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

bin/gems/set-1.1.1/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

bin/gems/set-1.1.1/lib/set.rb

@@ -0,0 +1,855 @@
+# frozen_string_literal: true
+# :markup: markdown
+#
+# set.rb - defines the Set class
+#
+# Copyright (c) 2002-2024 Akinori MUSHA <knu@iDaemons.org>
+#
+# Documentation by Akinori MUSHA and Gavin Sinclair.
+#
+# All rights reserved.  You can redistribute and/or modify it under the same
+# terms as Ruby.
+
+
+##
+# This library provides the Set class, which implements a collection
+# of unordered values with no duplicates. It is a hybrid of Array's
+# intuitive inter-operation facilities and Hash's fast lookup.
+#
+# The method `to_set` is added to Enumerable for convenience.
+#
+# Set is easy to use with Enumerable objects (implementing `each`).
+# Most of the initializer methods and binary operators accept generic
+# Enumerable objects besides sets and arrays.  An Enumerable object
+# can be converted to Set using the `to_set` method.
+#
+# Set uses Hash as storage, so you must note the following points:
+#
+# * Equality of elements is determined according to Object#eql? and
+#   Object#hash.  Use Set#compare_by_identity to make a set compare
+#   its elements by their identity.
+# * Set assumes that the identity of each element does not change
+#   while it is stored.  Modifying an element of a set will render the
+#   set to an unreliable state.
+# * When a string is to be stored, a frozen copy of the string is
+#   stored instead unless the original string is already frozen.
+#
+# ## Comparison
+#
+# The comparison operators `<`, `>`, `<=`, and `>=` are implemented as
+# shorthand for the {proper_,}{subset?,superset?} methods.  The `<=>`
+# operator reflects this order, or return `nil` for sets that both
+# have distinct elements (`{x, y}` vs. `{x, z}` for example).
+#
+# ## Example
+#
+# ```ruby
+# require 'set'
+# s1 = Set[1, 2]                        #=> #<Set: {1, 2}>
+# s2 = [1, 2].to_set                    #=> #<Set: {1, 2}>
+# s1 == s2                              #=> true
+# s1.add("foo")                         #=> #<Set: {1, 2, "foo"}>
+# s1.merge([2, 6])                      #=> #<Set: {1, 2, "foo", 6}>
+# s1.subset?(s2)                        #=> false
+# s2.subset?(s1)                        #=> true
+# ```
+#
+# ## Contact
+#
+# - Akinori MUSHA <<knu@iDaemons.org>> (current maintainer)
+#
+# ## What's Here
+#
+#  First, what's elsewhere. \Class \Set:
+#
+# - Inherits from {class Object}[https://docs.ruby-lang.org/en/master/Object.html#class-Object-label-What-27s+Here].
+# - Includes {module Enumerable}[https://docs.ruby-lang.org/en/master/Enumerable.html#module-Enumerable-label-What-27s+Here],
+#   which provides dozens of additional methods.
+#
+# In particular, class \Set does not have many methods of its own
+# for fetching or for iterating.
+# Instead, it relies on those in \Enumerable.
+#
+# Here, class \Set provides methods that are useful for:
+#
+# - [Creating a Set](#class-Set-label-Methods+for+Creating+a+Set)
+# - [Set Operations](#class-Set-label-Methods+for+Set+Operations)
+# - [Comparing](#class-Set-label-Methods+for+Comparing)
+# - [Querying](#class-Set-label-Methods+for+Querying)
+# - [Assigning](#class-Set-label-Methods+for+Assigning)
+# - [Deleting](#class-Set-label-Methods+for+Deleting)
+# - [Converting](#class-Set-label-Methods+for+Converting)
+# - [Iterating](#class-Set-label-Methods+for+Iterating)
+# - [And more....](#class-Set-label-Other+Methods)
+#
+# ### Methods for Creating a \Set
+#
+# - ::[]:
+#   Returns a new set containing the given objects.
+# - ::new:
+#   Returns a new set containing either the given objects
+#   (if no block given) or the return values from the called block
+#   (if a block given).
+#
+# ### Methods for \Set Operations
+#
+# - [|](#method-i-7C) (aliased as #union and #+):
+#   Returns a new set containing all elements from +self+
+#   and all elements from a given enumerable (no duplicates).
+# - [&](#method-i-26) (aliased as #intersection):
+#   Returns a new set containing all elements common to +self+
+#   and a given enumerable.
+# - [-](#method-i-2D) (aliased as #difference):
+#   Returns a copy of +self+ with all elements
+#   in a given enumerable removed.
+# - [\^](#method-i-5E):
+#   Returns a new set containing all elements from +self+
+#   and a given enumerable except those common to both.
+#
+# ### Methods for Comparing
+#
+# - [<=>](#method-i-3C-3D-3E):
+#   Returns -1, 0, or 1 as +self+ is less than, equal to,
+#   or greater than a given object.
+# - [==](#method-i-3D-3D):
+#   Returns whether +self+ and a given enumerable are equal,
+#   as determined by Object#eql?.
+# - \#compare_by_identity?:
+#   Returns whether the set considers only identity
+#   when comparing elements.
+#
+# ### Methods for Querying
+#
+# - \#length (aliased as #size):
+#   Returns the count of elements.
+# - \#empty?:
+#   Returns whether the set has no elements.
+# - \#include? (aliased as #member? and #===):
+#   Returns whether a given object is an element in the set.
+# - \#subset? (aliased as [<=](#method-i-3C-3D)):
+#   Returns whether a given object is a subset of the set.
+# - \#proper_subset? (aliased as [<](#method-i-3C)):
+#   Returns whether a given enumerable is a proper subset of the set.
+# - \#superset? (aliased as [>=](#method-i-3E-3D])):
+#   Returns whether a given enumerable is a superset of the set.
+# - \#proper_superset? (aliased as [>](#method-i-3E)):
+#   Returns whether a given enumerable is a proper superset of the set.
+# - \#disjoint?:
+#   Returns +true+ if the set and a given enumerable
+#   have no common elements, +false+ otherwise.
+# - \#intersect?:
+#   Returns +true+ if the set and a given enumerable:
+#   have any common elements, +false+ otherwise.
+# - \#compare_by_identity?:
+#   Returns whether the set considers only identity
+#   when comparing elements.
+#
+# ### Methods for Assigning
+#
+# - \#add (aliased as #<<):
+#   Adds a given object to the set; returns +self+.
+# - \#add?:
+#   If the given object is not an element in the set,
+#   adds it and returns +self+; otherwise, returns +nil+.
+# - \#merge:
+#   Merges the elements of each given enumerable object to the set; returns +self+.
+# - \#replace:
+#   Replaces the contents of the set with the contents
+#   of a given enumerable.
+#
+# ### Methods for Deleting
+#
+# - \#clear:
+#   Removes all elements in the set; returns +self+.
+# - \#delete:
+#   Removes a given object from the set; returns +self+.
+# - \#delete?:
+#   If the given object is an element in the set,
+#   removes it and returns +self+; otherwise, returns +nil+.
+# - \#subtract:
+#   Removes each given object from the set; returns +self+.
+# - \#delete_if - Removes elements specified by a given block.
+# - \#select! (aliased as #filter!):
+#   Removes elements not specified by a given block.
+# - \#keep_if:
+#   Removes elements not specified by a given block.
+# - \#reject!
+#   Removes elements specified by a given block.
+#
+# ### Methods for Converting
+#
+# - \#classify:
+#   Returns a hash that classifies the elements,
+#   as determined by the given block.
+# - \#collect! (aliased as #map!):
+#   Replaces each element with a block return-value.
+# - \#divide:
+#   Returns a hash that classifies the elements,
+#   as determined by the given block;
+#   differs from #classify in that the block may accept
+#   either one or two arguments.
+# - \#flatten:
+#   Returns a new set that is a recursive flattening of +self+.
+#  \#flatten!:
+#   Replaces each nested set in +self+ with the elements from that set.
+# - \#inspect (aliased as #to_s):
+#   Returns a string displaying the elements.
+# - \#join:
+#   Returns a string containing all elements, converted to strings
+#   as needed, and joined by the given record separator.
+# - \#to_a:
+#   Returns an array containing all set elements.
+# - \#to_set:
+#   Returns +self+ if given no arguments and no block;
+#   with a block given, returns a new set consisting of block
+#   return values.
+#
+# ### Methods for Iterating
+#
+# - \#each:
+#   Calls the block with each successive element; returns +self+.
+#
+# ### Other Methods
+#
+# - \#reset:
+#   Resets the internal state; useful if an object
+#   has been modified while an element in the set.
+#
+class Set
+  VERSION = "1.1.1"
+
+  include Enumerable
+
+  # Creates a new set containing the given objects.
+  #
+  #     Set[1, 2]                   # => #<Set: {1, 2}>
+  #     Set[1, 2, 1]                # => #<Set: {1, 2}>
+  #     Set[1, 'c', :s]             # => #<Set: {1, "c", :s}>
+  def self.[](*ary)
+    new(ary)
+  end
+
+  # Creates a new set containing the elements of the given enumerable
+  # object.
+  #
+  # If a block is given, the elements of enum are preprocessed by the
+  # given block.
+  #
+  #     Set.new([1, 2])                       #=> #<Set: {1, 2}>
+  #     Set.new([1, 2, 1])                    #=> #<Set: {1, 2}>
+  #     Set.new([1, 'c', :s])                 #=> #<Set: {1, "c", :s}>
+  #     Set.new(1..5)                         #=> #<Set: {1, 2, 3, 4, 5}>
+  #     Set.new([1, 2, 3]) { |x| x * x }      #=> #<Set: {1, 4, 9}>
+  def initialize(enum = nil, &block) # :yields: o
+    @hash ||= Hash.new(false)
+
+    enum.nil? and return
+
+    if block
+      do_with_enum(enum) { |o| add(block[o]) }
+    else
+      merge(enum)
+    end
+  end
+
+  # Makes the set compare its elements by their identity and returns
+  # self.  This method may not be supported by all subclasses of Set.
+  def compare_by_identity
+    if @hash.respond_to?(:compare_by_identity)
+      @hash.compare_by_identity
+      self
+    else
+      raise NotImplementedError, "#{self.class.name}\##{__method__} is not implemented"
+    end
+  end
+
+  # Returns true if the set will compare its elements by their
+  # identity.  Also see Set#compare_by_identity.
+  def compare_by_identity?
+    @hash.respond_to?(:compare_by_identity?) && @hash.compare_by_identity?
+  end
+
+  def do_with_enum(enum, &block) # :nodoc:
+    if enum.respond_to?(:each_entry)
+      enum.each_entry(&block) if block
+    elsif enum.respond_to?(:each)
+      enum.each(&block) if block
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+  private :do_with_enum
+
+  # Dup internal hash.
+  def initialize_dup(orig)
+    super
+    @hash = orig.instance_variable_get(:@hash).dup
+  end
+
+  # Clone internal hash.
+  def initialize_clone(orig, **options)
+    super
+    @hash = orig.instance_variable_get(:@hash).clone(**options)
+  end
+
+  def freeze    # :nodoc:
+    @hash.freeze
+    super
+  end
+
+  # Returns the number of elements.
+  def size
+    @hash.size
+  end
+  alias length size
+
+  # Returns true if the set contains no elements.
+  def empty?
+    @hash.empty?
+  end
+
+  # Removes all elements and returns self.
+  #
+  #     set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
+  #     set.clear                         #=> #<Set: {}>
+  #     set                               #=> #<Set: {}>
+  def clear
+    @hash.clear
+    self
+  end
+
+  # Replaces the contents of the set with the contents of the given
+  # enumerable object and returns self.
+  #
+  #     set = Set[1, 'c', :s]             #=> #<Set: {1, "c", :s}>
+  #     set.replace([1, 2])               #=> #<Set: {1, 2}>
+  #     set                               #=> #<Set: {1, 2}>
+  def replace(enum)
+    if enum.instance_of?(self.class)
+      @hash.replace(enum.instance_variable_get(:@hash))
+      self
+    else
+      do_with_enum(enum)  # make sure enum is enumerable before calling clear
+      clear
+      merge(enum)
+    end
+  end
+
+  # Returns an array containing all elements in the set.
+  #
+  #     Set[1, 2].to_a                    #=> [1, 2]
+  #     Set[1, 'c', :s].to_a              #=> [1, "c", :s]
+  def to_a
+    @hash.keys
+  end
+
+  # Returns self if no arguments are given.  Otherwise, converts the
+  # set to another with `klass.new(self, *args, &block)`.
+  #
+  # In subclasses, returns `klass.new(self, *args, &block)` unless
+  # overridden.
+  def to_set(klass = Set, *args, &block)
+    return self if instance_of?(Set) && klass == Set && block.nil? && args.empty?
+    klass.new(self, *args, &block)
+  end
+
+  def flatten_merge(set, seen = {}) # :nodoc:
+    set.each { |e|
+      if e.is_a?(Set)
+        case seen[e_id = e.object_id]
+        when true
+          raise ArgumentError, "tried to flatten recursive Set"
+        when false
+          next
+        end
+
+        seen[e_id] = true
+        flatten_merge(e, seen)
+        seen[e_id] = false
+      else
+        add(e)
+      end
+    }
+
+    self
+  end
+  protected :flatten_merge
+
+  # Returns a new set that is a copy of the set, flattening each
+  # containing set recursively.
+  def flatten
+    self.class.new.flatten_merge(self)
+  end
+
+  # Equivalent to Set#flatten, but replaces the receiver with the
+  # result in place.  Returns nil if no modifications were made.
+  def flatten!
+    replace(flatten()) if any?(Set)
+  end
+
+  # Returns true if the set contains the given object.
+  #
+  # Note that <code>include?</code> and <code>member?</code> do not test member
+  # equality using <code>==</code> as do other Enumerables.
+  #
+  # See also Enumerable#include?
+  def include?(o)
+    @hash[o]
+  end
+  alias member? include?
+
+  # Returns true if the set is a superset of the given set.
+  def superset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:>=)
+      @hash >= set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size >= set.size && set.all?(self)
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias >= superset?
+
+  # Returns true if the set is a proper superset of the given set.
+  def proper_superset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:>)
+      @hash > set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size > set.size && set.all?(self)
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias > proper_superset?
+
+  # Returns true if the set is a subset of the given set.
+  def subset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:<=)
+      @hash <= set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size <= set.size && all?(set)
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias <= subset?
+
+  # Returns true if the set is a proper subset of the given set.
+  def proper_subset?(set)
+    case
+    when set.instance_of?(self.class) && @hash.respond_to?(:<)
+      @hash < set.instance_variable_get(:@hash)
+    when set.is_a?(Set)
+      size < set.size && all?(set)
+    else
+      raise ArgumentError, "value must be a set"
+    end
+  end
+  alias < proper_subset?
+
+  # Returns 0 if the set are equal,
+  # -1 / +1 if the set is a proper subset / superset of the given set,
+  # or nil if they both have unique elements.
+  def <=>(set)
+    return unless set.is_a?(Set)
+
+    case size <=> set.size
+    when -1 then -1 if proper_subset?(set)
+    when +1 then +1 if proper_superset?(set)
+    else 0 if self.==(set)
+    end
+  end
+
+  # Returns true if the set and the given enumerable have at least one
+  # element in common.
+  #
+  #     Set[1, 2, 3].intersect? Set[4, 5]   #=> false
+  #     Set[1, 2, 3].intersect? Set[3, 4]   #=> true
+  #     Set[1, 2, 3].intersect? 4..5        #=> false
+  #     Set[1, 2, 3].intersect? [3, 4]      #=> true
+  def intersect?(set)
+    case set
+    when Set
+      if size < set.size
+        any?(set)
+      else
+        set.any?(self)
+      end
+    when Enumerable
+      set.any?(self)
+    else
+      raise ArgumentError, "value must be enumerable"
+    end
+  end
+
+  # Returns true if the set and the given enumerable have
+  # no element in common.  This method is the opposite of `intersect?`.
+  #
+  #     Set[1, 2, 3].disjoint? Set[3, 4]   #=> false
+  #     Set[1, 2, 3].disjoint? Set[4, 5]   #=> true
+  #     Set[1, 2, 3].disjoint? [3, 4]      #=> false
+  #     Set[1, 2, 3].disjoint? 4..5        #=> true
+  def disjoint?(set)
+    !intersect?(set)
+  end
+
+  # Calls the given block once for each element in the set, passing
+  # the element as parameter.  Returns an enumerator if no block is
+  # given.
+  def each(&block)
+    block_given? or return enum_for(__method__) { size }
+    @hash.each_key(&block)
+    self
+  end
+
+  # Adds the given object to the set and returns self.  Use `merge` to
+  # add many elements at once.
+  #
+  #     Set[1, 2].add(3)                    #=> #<Set: {1, 2, 3}>
+  #     Set[1, 2].add([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
+  #     Set[1, 2].add(2)                    #=> #<Set: {1, 2}>
+  def add(o)
+    @hash[o] = true
+    self
+  end
+  alias << add
+
+  # Adds the given object to the set and returns self.  If the
+  # object is already in the set, returns nil.
+  #
+  #     Set[1, 2].add?(3)                    #=> #<Set: {1, 2, 3}>
+  #     Set[1, 2].add?([3, 4])               #=> #<Set: {1, 2, [3, 4]}>
+  #     Set[1, 2].add?(2)                    #=> nil
+  def add?(o)
+    add(o) unless include?(o)
+  end
+
+  # Deletes the given object from the set and returns self.  Use
+  # `subtract` to delete many items at once.
+  def delete(o)
+    @hash.delete(o)
+    self
+  end
+
+  # Deletes the given object from the set and returns self.  If the
+  # object is not in the set, returns nil.
+  def delete?(o)
+    delete(o) if include?(o)
+  end
+
+  # Deletes every element of the set for which block evaluates to
+  # true, and returns self. Returns an enumerator if no block is
+  # given.
+  def delete_if(&block)
+    block_given? or return enum_for(__method__) { size }
+    # Instead of directly using @hash.delete_if, perform enumeration
+    # using self.each that subclasses may override.
+    select(&block).each { |o| @hash.delete(o) }
+    self
+  end
+
+  # Deletes every element of the set for which block evaluates to
+  # false, and returns self. Returns an enumerator if no block is
+  # given.
+  def keep_if(&block)
+    block_given? or return enum_for(__method__) { size }
+    # Instead of directly using @hash.keep_if, perform enumeration
+    # using self.each that subclasses may override.
+    reject(&block).each { |o| @hash.delete(o) }
+    self
+  end
+
+  # Replaces the elements with ones returned by `collect()`.
+  # Returns an enumerator if no block is given.
+  def collect!
+    block_given? or return enum_for(__method__) { size }
+    set = self.class.new
+    each { |o| set << yield(o) }
+    replace(set)
+  end
+  alias map! collect!
+
+  # Equivalent to Set#delete_if, but returns nil if no changes were
+  # made. Returns an enumerator if no block is given.
+  def reject!(&block)
+    block_given? or return enum_for(__method__) { size }
+    n = size
+    delete_if(&block)
+    self if size != n
+  end
+
+  # Equivalent to Set#keep_if, but returns nil if no changes were
+  # made. Returns an enumerator if no block is given.
+  def select!(&block)
+    block_given? or return enum_for(__method__) { size }
+    n = size
+    keep_if(&block)
+    self if size != n
+  end
+
+  # Equivalent to Set#select!
+  alias filter! select!
+
+  # Merges the elements of the given enumerable objects to the set and
+  # returns self.
+  def merge(*enums, **nil)
+    enums.each do |enum|
+      if enum.instance_of?(self.class)
+        @hash.update(enum.instance_variable_get(:@hash))
+      else
+        do_with_enum(enum) { |o| add(o) }
+      end
+    end
+
+    self
+  end
+
+  # Deletes every element that appears in the given enumerable object
+  # and returns self.
+  def subtract(enum)
+    do_with_enum(enum) { |o| delete(o) }
+    self
+  end
+
+  # Returns a new set built by merging the set and the elements of the
+  # given enumerable object.
+  #
+  #     Set[1, 2, 3] | Set[2, 4, 5]         #=> #<Set: {1, 2, 3, 4, 5}>
+  #     Set[1, 5, 'z'] | (1..6)             #=> #<Set: {1, 5, "z", 2, 3, 4, 6}>
+  def |(enum)
+    dup.merge(enum)
+  end
+  alias + |
+  alias union |
+
+  # Returns a new set built by duplicating the set, removing every
+  # element that appears in the given enumerable object.
+  #
+  #     Set[1, 3, 5] - Set[1, 5]                #=> #<Set: {3}>
+  #     Set['a', 'b', 'z'] - ['a', 'c']         #=> #<Set: {"b", "z"}>
+  def -(enum)
+    dup.subtract(enum)
+  end
+  alias difference -
+
+  # Returns a new set containing elements common to the set and the
+  # given enumerable object.
+  #
+  #     Set[1, 3, 5] & Set[3, 2, 1]             #=> #<Set: {3, 1}>
+  #     Set['a', 'b', 'z'] & ['a', 'b', 'c']    #=> #<Set: {"a", "b"}>
+  def &(enum)
+    n = self.class.new
+    if enum.is_a?(Set)
+      if enum.size > size
+        each { |o| n.add(o) if enum.include?(o) }
+      else
+        enum.each { |o| n.add(o) if include?(o) }
+      end
+    else
+      do_with_enum(enum) { |o| n.add(o) if include?(o) }
+    end
+    n
+  end
+  alias intersection &
+
+  # Returns a new set containing elements exclusive between the set
+  # and the given enumerable object.  `(set ^ enum)` is equivalent to
+  # `((set | enum) - (set & enum))`.
+  #
+  #     Set[1, 2] ^ Set[2, 3]                   #=> #<Set: {3, 1}>
+  #     Set[1, 'b', 'c'] ^ ['b', 'd']           #=> #<Set: {"d", 1, "c"}>
+  def ^(enum)
+    n = self.class.new(enum)
+    each { |o| n.add(o) unless n.delete?(o) }
+    n
+  end
+
+  # Returns true if two sets are equal.  The equality of each couple
+  # of elements is defined according to Object#eql?.
+  #
+  #     Set[1, 2] == Set[2, 1]                       #=> true
+  #     Set[1, 3, 5] == Set[1, 5]                    #=> false
+  #     Set['a', 'b', 'c'] == Set['a', 'c', 'b']     #=> true
+  #     Set['a', 'b', 'c'] == ['a', 'c', 'b']        #=> false
+  def ==(other)
+    if self.equal?(other)
+      true
+    elsif other.instance_of?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    elsif other.is_a?(Set) && self.size == other.size
+      other.all? { |o| @hash.include?(o) }
+    else
+      false
+    end
+  end
+
+  def hash      # :nodoc:
+    @hash.hash
+  end
+
+  def eql?(o)   # :nodoc:
+    return false unless o.is_a?(Set)
+    @hash.eql?(o.instance_variable_get(:@hash))
+  end
+
+  # Resets the internal state after modification to existing elements
+  # and returns self.
+  #
+  # Elements will be reindexed and deduplicated.
+  def reset
+    if @hash.respond_to?(:rehash)
+      @hash.rehash # This should perform frozenness check.
+    else
+      raise FrozenError, "can't modify frozen #{self.class.name}" if frozen?
+    end
+    self
+  end
+
+  # Returns true if the given object is a member of the set,
+  # and false otherwise.
+  #
+  # Used in case statements:
+  #
+  #     require 'set'
+  #
+  #     case :apple
+  #     when Set[:potato, :carrot]
+  #       "vegetable"
+  #     when Set[:apple, :banana]
+  #       "fruit"
+  #     end
+  #     # => "fruit"
+  #
+  # Or by itself:
+  #
+  #     Set[1, 2, 3] === 2   #=> true
+  #     Set[1, 2, 3] === 4   #=> false
+  #
+  alias === include?
+
+  # Classifies the set by the return value of the given block and
+  # returns a hash of {value => set of elements} pairs.  The block is
+  # called once for each element of the set, passing the element as
+  # parameter.
+  #
+  #     require 'set'
+  #     files = Set.new(Dir.glob("*.rb"))
+  #     hash = files.classify { |f| File.mtime(f).year }
+  #     hash       #=> {2000=>#<Set: {"a.rb", "b.rb"}>,
+  #                #    2001=>#<Set: {"c.rb", "d.rb", "e.rb"}>,
+  #                #    2002=>#<Set: {"f.rb"}>}
+  #
+  # Returns an enumerator if no block is given.
+  def classify # :yields: o
+    block_given? or return enum_for(__method__) { size }
+
+    h = {}
+
+    each { |i|
+      (h[yield(i)] ||= self.class.new).add(i)
+    }
+
+    h
+  end
+
+  # Divides the set into a set of subsets according to the commonality
+  # defined by the given block.
+  #
+  # If the arity of the block is 2, elements o1 and o2 are in common
+  # if block.call(o1, o2) is true.  Otherwise, elements o1 and o2 are
+  # in common if block.call(o1) == block.call(o2).
+  #
+  #     require 'set'
+  #     numbers = Set[1, 3, 4, 6, 9, 10, 11]
+  #     set = numbers.divide { |i,j| (i - j).abs == 1 }
+  #     set        #=> #<Set: {#<Set: {1}>,
+  #                #           #<Set: {11, 9, 10}>,
+  #                #           #<Set: {3, 4}>,
+  #                #           #<Set: {6}>}>
+  #
+  # Returns an enumerator if no block is given.
+  def divide(&func)
+    func or return enum_for(__method__) { size }
+
+    if func.arity == 2
+      require 'tsort'
+
+      class << dig = {}         # :nodoc:
+        include TSort
+
+        alias tsort_each_node each_key
+        def tsort_each_child(node, &block)
+          fetch(node).each(&block)
+        end
+      end
+
+      each { |u|
+        dig[u] = a = []
+        each{ |v| func.call(u, v) and a << v }
+      }
+
+      set = Set.new()
+      dig.each_strongly_connected_component { |css|
+        set.add(self.class.new(css))
+      }
+      set
+    else
+      Set.new(classify(&func).values)
+    end
+  end
+
+  # Returns a string created by converting each element of the set to a string
+  # See also: Array#join
+  def join(separator=nil)
+    to_a.join(separator)
+  end
+
+  InspectKey = :__inspect_key__         # :nodoc:
+
+  # Returns a string containing a human-readable representation of the
+  # set ("#<Set: {element1, element2, ...}>").
+  def inspect
+    ids = (Thread.current[InspectKey] ||= [])
+
+    if ids.include?(object_id)
+      return sprintf('#<%s: {...}>', self.class.name)
+    end
+
+    ids << object_id
+    begin
+      return sprintf('#<%s: {%s}>', self.class, to_a.inspect[1..-2])
+    ensure
+      ids.pop
+    end
+  end
+
+  alias to_s inspect
+
+  def pretty_print(pp)  # :nodoc:
+    pp.group(1, sprintf('#<%s:', self.class.name), '>') {
+      pp.breakable
+      pp.group(1, '{', '}') {
+        pp.seplist(self) { |o|
+          pp.pp o
+        }
+      }
+    }
+  end
+
+  def pretty_print_cycle(pp)    # :nodoc:
+    pp.text sprintf('#<%s: {%s}>', self.class.name, empty? ? '' : '...')
+  end
+end
+
+module Enumerable
+  # Makes a set from the enumerable object with given arguments.
+  # Needs to `require "set"` to use this method.
+  def to_set(klass = Set, *args, &block)
+    klass.new(self, *args, &block)
+  end unless method_defined?(:to_set)
+end
+
+autoload :SortedSet, "#{__dir__}/set/sorted_set"

bin/gems/set-1.1.1/lib/set/sorted_set.rb

@@ -0,0 +1,6 @@
+begin
+  require 'sorted_set'
+rescue ::LoadError
+  raise "The `SortedSet` class has been extracted from the `set` library. " \
+        "You must use the `sorted_set` gem or other alternatives."
+end

bin/gems/set-1.1.1/set.gemspec

@@ -0,0 +1,30 @@
+name = File.basename(__FILE__, ".gemspec")
+version = ["lib", Array.new(name.count("-")+1, "..").join("/")].find do |dir|
+  break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
+    /^\s*VERSION\s*=\s*"(.*)"/ =~ line and break $1
+  end rescue nil
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = name
+  spec.version       = version
+  spec.authors       = ["Akinori MUSHA"]
+  spec.email         = ["knu@idaemons.org"]
+
+  spec.summary       = %q{Provides a class to deal with collections of unordered, unique values}
+  spec.description   = %q{Provides a class to deal with collections of unordered, unique values}
+  spec.homepage      = "https://github.com/ruby/set"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.0.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/ruby/set/blob/v#{spec.version}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+end