tdiary 5.4.0 → 5.5.0.beta1

data/vendor/bundle/ruby/3.4.0/gems/thor-1.5.0/thor.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path("../lib/", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+require "thor/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "thor"
+  spec.version = Thor::VERSION
+  spec.licenses = %w(MIT)
+  spec.authors = ["Yehuda Katz", "José Valim"]
+  spec.email = "ruby-thor@googlegroups.com"
+  spec.homepage = "https://github.com/rails/thor"
+  spec.description = "Thor is a toolkit for building powerful command-line interfaces."
+  spec.summary = spec.description
+
+  spec.metadata = {
+    "bug_tracker_uri" => "https://github.com/rails/thor/issues",
+    "changelog_uri" => "https://github.com/rails/thor/releases/tag/v#{Thor::VERSION}",
+    "documentation_uri" => "https://github.com/rails/thor/wiki",
+    "source_code_uri" => "https://github.com/rails/thor/tree/v#{Thor::VERSION}",
+    "wiki_uri" => "https://github.com/rails/thor/wiki",
+    "rubygems_mfa_required" => "true",
+  }
+
+  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_rubygems_version = ">= 1.3.5"
+
+  spec.files = %w(.document thor.gemspec) + Dir["*.md", "bin/*", "lib/**/*.rb"]
+  spec.executables = %w(thor)
+  spec.require_paths = %w(lib)
+
+  spec.add_development_dependency "bundler", ">= 1.0"
+end

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/BSDL

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. 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.

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/COPYING

@@ -0,0 +1,56 @@
+Ruby is copyrighted free software by Yukihiro Matsumoto <matz@netlab.jp>.
+You can redistribute it and/or modify it under either the terms of the
+2-clause BSDL (see the file BSDL), or the conditions below:
+
+1. You may make and give away verbatim copies of the source form of the
+   software without restriction, provided that you duplicate all of the
+   original copyright notices and associated disclaimers.
+
+2. You may modify your copy of the software in any way, provided that
+   you do at least ONE of the following:
+
+   a. place your modifications in the Public Domain or otherwise
+      make them Freely Available, such as by posting said
+      modifications to Usenet or an equivalent medium, or by allowing
+      the author to include your modifications in the software.
+
+   b. use the modified software only within your corporation or
+      organization.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+3. You may distribute the software in object code or binary form,
+   provided that you do at least ONE of the following:
+
+   a. distribute the binaries and library files of the software,
+      together with instructions (in the manual page or equivalent)
+      on where to get the original distribution.
+
+   b. accompany the distribution with the machine-readable source of
+      the software.
+
+   c. give non-standard binaries non-standard names, with
+      instructions on where to get the original software distribution.
+
+   d. make other distribution arrangements with the author.
+
+4. You may modify and include the part of the software into any other
+   software (possibly commercial).  But some files in the distribution
+   are not written by the author, so that they are not under these terms.
+
+   For the list of those files and their copying conditions, see the
+   file LEGAL.
+
+5. The scripts and library files supplied as input to or produced as
+   output from the software do not automatically fall under the
+   copyright of the software, but belong to whomever generated them,
+   and may be sold commercially, and may be aggregated with this
+   software.
+
+6. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+   IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   PURPOSE.

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+
+gemspec
+
+group :development do
+  gem "bundler"
+  gem "rake"
+  gem "test-unit"
+  gem "test-unit-ruby-core"
+end

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/README.md

@@ -0,0 +1,39 @@
+# Timeout
+
+Timeout provides a way to auto-terminate a potentially long-running
+operation if it hasn't finished in a fixed amount of time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'timeout'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install timeout
+
+## Usage
+
+```ruby
+require 'timeout'
+status = Timeout.timeout(5) {
+  # Something that should be interrupted if it takes more than 5 seconds...
+}
+```
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/timeout.

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/lib/timeout.rb

@@ -0,0 +1,314 @@
+# frozen_string_literal: true
+# Timeout long-running blocks
+#
+# == Synopsis
+#
+#   require 'timeout'
+#   status = Timeout.timeout(5) {
+#     # Something that should be interrupted if it takes more than 5 seconds...
+#   }
+#
+# == Description
+#
+# Timeout provides a way to auto-terminate a potentially long-running
+# operation if it hasn't finished in a fixed amount of time.
+#
+# == Copyright
+#
+# Copyright:: (C) 2000  Network Applied Communication Laboratory, Inc.
+# Copyright:: (C) 2000  Information-technology Promotion Agency, Japan
+
+module Timeout
+  # The version
+  VERSION = "0.6.1"
+
+  # Internal exception raised to when a timeout is triggered.
+  class ExitException < Exception
+    def exception(*) # :nodoc:
+      self
+    end
+  end
+
+  # Raised by Timeout.timeout when the block times out.
+  class Error < RuntimeError
+    def self.handle_timeout(message) # :nodoc:
+      exc = ExitException.new(message)
+
+      begin
+        yield exc
+      rescue ExitException => e
+        raise new(message) if exc.equal?(e)
+        raise
+      end
+    end
+  end
+
+  # :stopdoc:
+
+  # We keep a private reference so that time mocking libraries won't break Timeout.
+  GET_TIME = Process.method(:clock_gettime)
+  if defined?(Ractor.make_shareable)
+    # Ractor.make_shareable(Method) only works on Ruby 4+
+    Ractor.make_shareable(GET_TIME) rescue nil
+  end
+  private_constant :GET_TIME
+
+  class State
+    def initialize
+      @condvar = ConditionVariable.new
+      @queue = Queue.new
+      @queue_mutex = Mutex.new
+
+      @timeout_thread = nil
+      @timeout_thread_mutex = Mutex.new
+    end
+
+    if defined?(Ractor.store_if_absent) && defined?(Ractor.shareable?) && Ractor.shareable?(GET_TIME)
+      # Ractor support if
+      # 1. Ractor.store_if_absent is available
+      # 2. Method object can be shareable (4.0~)
+      def self.instance
+        Ractor.store_if_absent :timeout_gem_state do
+          State.new
+        end
+      end
+    else
+      GLOBAL_STATE = State.new
+
+      def self.instance
+        GLOBAL_STATE
+      end
+    end
+
+    def create_timeout_thread
+      # Threads unexpectedly inherit the interrupt mask: https://github.com/ruby/timeout/issues/41
+      # So reset the interrupt mask to the default one for the timeout thread
+      Thread.handle_interrupt(Object => :immediate) do
+        watcher = Thread.new do
+          requests = []
+          while true
+            until @queue.empty? and !requests.empty? # wait to have at least one request
+              req = @queue.pop
+              requests << req unless req.done?
+            end
+            closest_deadline = requests.min_by(&:deadline).deadline
+
+            now = 0.0
+            @queue_mutex.synchronize do
+              while (now = GET_TIME.call(Process::CLOCK_MONOTONIC)) < closest_deadline and @queue.empty?
+                @condvar.wait(@queue_mutex, closest_deadline - now)
+              end
+            end
+
+            requests.each do |req|
+              req.interrupt if req.expired?(now)
+            end
+            requests.reject!(&:done?)
+          end
+        end
+
+        if !watcher.group.enclosed? && (!defined?(Ractor.main?) || Ractor.main?)
+          ThreadGroup::Default.add(watcher)
+        end
+
+        watcher.name = "Timeout stdlib thread"
+        watcher.thread_variable_set(:"\0__detached_thread__", true)
+        watcher
+      end
+    end
+
+    def ensure_timeout_thread_created
+      unless @timeout_thread&.alive?
+        # If the Mutex is already owned we are in a signal handler.
+        # In that case, just return and let the main thread create the Timeout thread.
+        return if @timeout_thread_mutex.owned?
+
+        Sync.synchronize @timeout_thread_mutex do
+          unless @timeout_thread&.alive?
+            @timeout_thread = create_timeout_thread
+          end
+        end
+      end
+    end
+
+    def add_request(request)
+      Sync.synchronize @queue_mutex do
+        @queue << request
+        @condvar.signal
+      end
+    end
+  end
+  private_constant :State
+
+  class Request
+    attr_reader :deadline
+
+    def initialize(thread, timeout, exception_class, message)
+      @thread = thread
+      @deadline = GET_TIME.call(Process::CLOCK_MONOTONIC) + timeout
+      @exception_class = exception_class
+      @message = message
+
+      @mutex = Mutex.new
+      @done = false # protected by @mutex
+    end
+
+    # Only called by the timeout thread, so does not need Sync.synchronize
+    def done?
+      @mutex.synchronize do
+        @done
+      end
+    end
+
+    def expired?(now)
+      now >= @deadline
+    end
+
+    # Only called by the timeout thread, so does not need Sync.synchronize
+    def interrupt
+      @mutex.synchronize do
+        unless @done
+          @thread.raise @exception_class, @message
+          @done = true
+        end
+      end
+    end
+
+    def finished
+      Sync.synchronize @mutex do
+        @done = true
+      end
+    end
+  end
+  private_constant :Request
+
+  module Sync
+    # Calls mutex.synchronize(&block) but if that fails on CRuby due to being in a trap handler,
+    # run mutex.synchronize(&block) in a separate Thread instead.
+    def self.synchronize(mutex, &block)
+      begin
+        mutex.synchronize(&block)
+      rescue ThreadError => e
+        raise e unless e.message == "can't be called from trap context"
+        # Workaround CRuby issue https://bugs.ruby-lang.org/issues/19473
+        # which raises on Mutex#synchronize in trap handler.
+        # It's expensive to create a Thread just for this,
+        # but better than failing.
+        Thread.new {
+          mutex.synchronize(&block)
+        }.join
+      end
+    end
+  end
+  private_constant :Sync
+
+  # :startdoc:
+
+  # Perform an operation in a block, raising an exception if it takes longer than
+  # +sec+ seconds to complete.
+  #
+  # +sec+:: Number of seconds to wait for the block to terminate. Any non-negative number
+  #         or nil may be used, including Floats to specify fractional seconds. A
+  #         value of 0 or +nil+ will execute the block without any timeout.
+  #         Any negative number will raise an ArgumentError.
+  # +klass+:: Exception Class to raise if the block fails to terminate
+  #           in +sec+ seconds.  Omitting will use the default, Timeout::Error.
+  # +message+:: Error message to raise with Exception Class.
+  #             Omitting will use the default, <tt>"execution expired"</tt>.
+  #
+  # Returns the result of the block *if* the block completed before
+  # +sec+ seconds, otherwise raises an exception, based on the value of +klass+.
+  #
+  # The exception raised to terminate the given block is the given +klass+, or
+  # Timeout::ExitException if +klass+ is not given. The reason for that behavior
+  # is that Timeout::Error inherits from RuntimeError and might be caught unexpectedly by +rescue+.
+  # Timeout::ExitException inherits from Exception so it will only be rescued by <tt>rescue Exception</tt>.
+  # Note that the Timeout::ExitException is translated to a Timeout::Error once it reaches the Timeout.timeout call,
+  # so outside that call it will be a Timeout::Error.
+  #
+  # In general, be aware that the code block may rescue the exception, and in such a case not respect the timeout.
+  # Also, the block can use +ensure+ to prevent the handling of the exception.
+  # For those reasons, this method cannot be relied on to enforce timeouts for untrusted blocks.
+  #
+  # If a scheduler is defined, it will be used to handle the timeout by invoking
+  # Fiber::Scheduler#timeout_after.
+  #
+  # Note that this is both a method of module Timeout, so you can <tt>include
+  # Timeout</tt> into your classes so they have a #timeout method, as well as
+  # a module method, so you can call it directly as Timeout.timeout().
+  #
+  # ==== Ensuring the exception does not fire inside ensure blocks
+  #
+  # When using Timeout.timeout, it can be desirable to ensure the timeout exception does not fire inside an +ensure+ block.
+  # The simplest and best way to do so is to put the Timeout.timeout call inside the body of the +begin+/+ensure+/+end+:
+  #
+  #     begin
+  #       Timeout.timeout(sec) { some_long_operation }
+  #     ensure
+  #       cleanup # safe, cannot be interrupted by timeout
+  #     end
+  #
+  # If that is not feasible, e.g. if there are +ensure+ blocks inside +some_long_operation+,
+  # they need to not be interrupted by timeout, and it's not possible to move these ensure blocks outside,
+  # one can use Thread.handle_interrupt to delay the timeout exception like so:
+  #
+  #     Thread.handle_interrupt(Timeout::Error => :never) {
+  #       Timeout.timeout(sec, Timeout::Error) do
+  #         setup # timeout cannot happen here, no matter how long it takes
+  #         Thread.handle_interrupt(Timeout::Error => :immediate) {
+  #           some_long_operation # timeout can happen here
+  #         }
+  #       ensure
+  #         cleanup # timeout cannot happen here, no matter how long it takes
+  #       end
+  #     }
+  #
+  # An important thing to note is the need to pass an exception +klass+ to Timeout.timeout,
+  # otherwise it does not work. Specifically, using <tt>Thread.handle_interrupt(Timeout::ExitException => ...)</tt>
+  # is unsupported and causes subtle errors like raising the wrong exception outside the block, do not use that.
+  #
+  # Note that Thread.handle_interrupt is somewhat dangerous because if setup or cleanup hangs
+  # then the current thread will hang too and the timeout will never fire.
+  # Also note the block might run for longer than +sec+ seconds:
+  # e.g. +some_long_operation+ executes for +sec+ seconds + whatever time cleanup takes.
+  #
+  # If you want the timeout to only happen on blocking operations, one can use +:on_blocking+
+  # instead of +:immediate+. However, that means if the block uses no blocking operations after +sec+ seconds,
+  # the block will not be interrupted.
+  def self.timeout(sec, klass = nil, message = nil, &block)   #:yield: +sec+
+    return yield(sec) if sec == nil or sec.zero?
+    raise ArgumentError, "Timeout sec must be a non-negative number" if 0 > sec
+
+    message ||= "execution expired"
+
+    if Fiber.respond_to?(:current_scheduler) && (scheduler = Fiber.current_scheduler)&.respond_to?(:timeout_after)
+      perform = Proc.new do |exc|
+        scheduler.timeout_after(sec, exc, message, &block)
+      end
+    else
+      state = State.instance
+      state.ensure_timeout_thread_created
+
+      perform = Proc.new do |exc|
+        request = Request.new(Thread.current, sec, exc, message)
+        state.add_request(request)
+        begin
+          return yield(sec)
+        ensure
+          request.finished
+        end
+      end
+    end
+
+    if klass
+      perform.call(klass)
+    else
+      Error.handle_timeout(message, &perform)
+    end
+  end
+
+  # See Timeout.timeout
+  private def timeout(*args, &block)
+    Timeout.timeout(*args, &block)
+  end
+end

data/vendor/bundle/ruby/3.4.0/gems/timeout-0.6.1/timeout.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+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       = ["Yukihiro Matsumoto"]
+  spec.email         = ["matz@ruby-lang.org"]
+
+  spec.summary       = %q{Auto-terminate potentially long-running operations in Ruby.}
+  spec.description   = %q{Auto-terminate potentially long-running operations in Ruby.}
+  spec.homepage      = "https://github.com/ruby/timeout"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = spec.homepage + "/releases"
+
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features|rakelib)/|\.(?:git|travis|circleci)|appveyor|Rakefile)})
+    end
+  end
+  spec.require_paths = ["lib"]
+end

data/vendor/bundle/ruby/3.4.0/specifications/base64-0.3.0.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+# stub: base64 0.3.0 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "base64".freeze
+  s.version = "0.3.0".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "changelog_uri" => "https://github.com/ruby/base64/releases", "homepage_uri" => "https://github.com/ruby/base64", "source_code_uri" => "https://github.com/ruby/base64" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Yusuke Endoh".freeze]
+  s.bindir = "exe".freeze
+  s.date = "1980-01-02"
+  s.description = "Support for encoding and decoding binary data using a Base64 representation.".freeze
+  s.email = ["mame@ruby-lang.org".freeze]
+  s.homepage = "https://github.com/ruby/base64".freeze
+  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.4".freeze)
+  s.rubygems_version = "3.6.7".freeze
+  s.summary = "Support for encoding and decoding binary data using a Base64 representation.".freeze
+
+  s.installed_by_version = "3.6.9".freeze
+end

data/vendor/bundle/ruby/3.4.0/specifications/cgi-0.5.2.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# stub: cgi 0.5.2 ruby lib
+# stub: ext/cgi/escape/extconf.rb
+
+Gem::Specification.new do |s|
+  s.name = "cgi".freeze
+  s.version = "0.5.2".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "changelog_uri" => "https://github.com/ruby/cgi/releases", "homepage_uri" => "https://github.com/ruby/cgi", "source_code_uri" => "https://github.com/ruby/cgi" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Yukihiro Matsumoto".freeze]
+  s.date = "2026-06-23"
+  s.description = "Support for the Common Gateway Interface protocol.".freeze
+  s.email = ["matz@ruby-lang.org".freeze]
+  s.extensions = ["ext/cgi/escape/extconf.rb".freeze]
+  s.files = ["ext/cgi/escape/extconf.rb".freeze]
+  s.homepage = "https://github.com/ruby/cgi".freeze
+  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0".freeze)
+  s.rubygems_version = "3.6.7".freeze
+  s.summary = "Support for the Common Gateway Interface protocol.".freeze
+
+  s.installed_by_version = "3.6.9".freeze
+end

data/vendor/bundle/ruby/3.4.0/specifications/date-3.5.1.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+# stub: date 3.5.1 ruby lib
+# stub: ext/date/extconf.rb
+
+Gem::Specification.new do |s|
+  s.name = "date".freeze
+  s.version = "3.5.1".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.metadata = { "changelog_uri" => "https://github.com/ruby/date/releases" } if s.respond_to? :metadata=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Tadayoshi Funaba".freeze]
+  s.date = "2025-12-10"
+  s.description = "The official date library for Ruby.".freeze
+  s.email = [nil]
+  s.extensions = ["ext/date/extconf.rb".freeze]
+  s.files = ["ext/date/extconf.rb".freeze]
+  s.homepage = "https://github.com/ruby/date".freeze
+  s.licenses = ["Ruby".freeze, "BSD-2-Clause".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.6.0".freeze)
+  s.rubygems_version = "3.5.22".freeze
+  s.summary = "The official date library for Ruby.".freeze
+
+  s.installed_by_version = "3.6.9".freeze
+end

data/vendor/bundle/ruby/3.4.0/specifications/emot-0.0.4.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+# stub: emot 0.0.4 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "emot".freeze
+  s.version = "0.0.4".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["kyoendo".freeze]
+  s.date = "2015-02-12"
+  s.description = "Yet another emoji handler.".freeze
+  s.email = ["postagie@gmail.com".freeze]
+  s.executables = ["emot".freeze]
+  s.files = ["bin/emot".freeze]
+  s.homepage = "https://github.com/melborne/emot".freeze
+  s.licenses = ["MIT".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 2.0.0".freeze)
+  s.rubygems_version = "2.4.5".freeze
+  s.summary = "Yet another emoji handler.".freeze
+
+  s.installed_by_version = "3.6.9".freeze
+
+  s.specification_version = 4
+
+  s.add_runtime_dependency(%q<thor>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<bundler>.freeze, ["~> 1.6".freeze])
+  s.add_development_dependency(%q<rake>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<rspec>.freeze, [">= 0".freeze])
+end

data/vendor/bundle/ruby/3.4.0/specifications/fastimage-2.4.1.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+# stub: fastimage 2.4.1 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "fastimage".freeze
+  s.version = "2.4.1".freeze
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
+  s.require_paths = ["lib".freeze]
+  s.authors = ["Stephen Sykes".freeze]
+  s.date = "2026-03-10"
+  s.description = "FastImage finds the size or type of an image given its uri by fetching as little as needed.".freeze
+  s.email = "sdsykes@gmail.com".freeze
+  s.extra_rdoc_files = ["README.md".freeze]
+  s.files = ["README.md".freeze]
+  s.homepage = "http://github.com/sdsykes/fastimage".freeze
+  s.licenses = ["MIT".freeze]
+  s.rdoc_options = ["--charset=UTF-8".freeze]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.9.2".freeze)
+  s.rubygems_version = "3.4.10".freeze
+  s.summary = "FastImage - Image info fast".freeze
+
+  s.installed_by_version = "3.6.9".freeze
+
+  s.specification_version = 4
+
+  s.add_development_dependency(%q<fakeweb-fi>.freeze, ["~> 1.3".freeze])
+  s.add_development_dependency(%q<rake>.freeze, [">= 10.5".freeze])
+  s.add_development_dependency(%q<rdoc>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<test-unit>.freeze, [">= 0".freeze])
+  s.add_development_dependency(%q<webrick>.freeze, [">= 0".freeze])
+end