unisec 0.0.1 → 0.0.3

data/lib/unisec/cli/cli.rb

@@ -1,9 +1,12 @@
 # frozen_string_literal: true
 
-require 'unisec/cli/surrogates'
+require 'unisec/cli/confusables'
 require 'unisec/cli/hexdump'
 require 'unisec/cli/properties'
-require 'unisec/cli/confusables'
+require 'unisec/cli/rugrep'
+require 'unisec/cli/size'
+require 'unisec/cli/surrogates'
+require 'unisec/cli/versions'
 
 module Unisec
   # Module used to create the CLI for the executable
@@ -14,14 +17,17 @@ module Unisec
 
       # Mapping between the (sub-)commands as seen by the user
       # on the command-line interface and the CLI modules in the lib
-      register 'surrogates to', Surrogates::To
-      register 'surrogates from', Surrogates::From
-      register 'hexdump', Hexdump
-      register 'properties list', Properties::List
-      register 'properties codepoints', Properties::Codepoints
-      register 'properties char', Properties::Char
       register 'confusables list', Confusables::List
       register 'confusables randomize', Confusables::Randomize
+      register 'grep', Grep
+      register 'hexdump', Hexdump
+      register 'properties char', Properties::Char
+      register 'properties codepoints', Properties::Codepoints
+      register 'properties list', Properties::List
+      register 'size', Size
+      register 'surrogates from', Surrogates::From
+      register 'surrogates to', Surrogates::To
+      register 'versions', Versions
     end
   end
 end

data/lib/unisec/cli/rugrep.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI command `unisec grep` for the class {Unisec::Rugrep} from the lib.
+      #
+      # Example:
+      #
+      # ```plaintext
+      # $ unisec grep 'FRENCH \w+'
+      # U+20A3  ₣    FRENCH FRANC SIGN
+      # U+1F35F 🍟    FRENCH FRIES
+      # ```
+      class Grep < Dry::CLI::Command
+        desc 'Search for Unicode code point names by regular expression'
+
+        argument :regexp, required: true,
+                          desc: 'regular expression'
+
+        # Hexdump of all Unicode encodings.
+        # @param regexp [Regexp] Regular expression without delimiters or modifiers.
+        #   Supports everything Ruby Regexp supports
+        def call(regexp: nil, **)
+          puts Unisec::Rugrep.regrep_display(regexp)
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/size.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI command `unisec size` for the class {Unisec::Size} from the lib.
+      #
+      # Example:
+      #
+      # ```plaintext
+      # $ unisec size 🧑🏼‍🔬
+      # Code point(s):   4
+      # Grapheme(s):     1
+      # UTF-8 byte(s):   15
+      # UTF-16 byte(s):  14
+      # UTF-32 byte(s):  16
+      # UTF-8 unit(s):   15
+      # UTF-16 unit(s):  7
+      # UTF-32 unit(s):  4
+      # ```
+      class Size < Dry::CLI::Command
+        desc 'All kinf of size information about a Unicode string'
+
+        argument :input, required: true,
+                         desc: 'String input'
+
+        # All kinf of size information about a Unicode string.
+        # @param input [String] Input sting we want to know the size of
+        def call(input: nil, **)
+          puts Unisec::Size.new(input).display
+        end
+      end
+    end
+  end
+end

data/lib/unisec/cli/versions.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+require 'unisec'
+
+module Unisec
+  module CLI
+    module Commands
+      # CLI command `unisec versions` for the class {Unisec::Versions} from the lib.
+      #
+      # Example:
+      #
+      # ```plaintext
+      # $ unisec versions
+      # Unicode:
+      # Unicode (Ruby)                    15.0.0
+      # Unicode (twitter_cldr gem)        14.0.0
+      # Unicode (unicode-confusable gem)  15.0.0
+      # ICU (twitter_cldr gem)            70.1
+      # CLDR (twitter_cldr gem)           40
+      # Unicode emoji (Ruby)              15.0
+      #
+      # Gems:
+      # unisec                            0.0.1
+      # twitter_cldr gem                  6.11.5
+      # unicode-confusable gem            1.9.0
+      # ```
+      class Versions < Dry::CLI::Command
+        desc 'Version of anything related to Unicode as used in unisec'
+
+        # Version of anything related to Unicode as used in unisec.
+        def call(**)
+          puts Unisec::Versions.display
+        end
+      end
+    end
+  end
+end

data/lib/unisec/properties.rb

@@ -50,7 +50,7 @@ module Unisec
     def self.codepoints_display(prop)
       codepoints = Properties.codepoints(prop)
       codepoints.each do |cp|
-        puts "#{Properties.char2codepoint(cp[:char]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
       end
       nil
     end
@@ -158,7 +158,7 @@ module Unisec
     # @example
     #   Unisec::Properties.char2codepoint('💎') # => "U+1F48E"
     def self.char2codepoint(chr)
-      "U+#{format('%.4x', chr.codepoints.first).upcase}"
+      Properties.deccp2stdhexcp(chr.codepoints.first)
     end
 
     # Display the code points in Unicode format for the given characters (code points as string)
@@ -174,5 +174,14 @@ module Unisec
       end
       out.join(' ')
     end
+
+    # Convert from decimal code point to standardized format hexadecimal code point
+    # @param int_cp [Integer] Code point in decimal format
+    # @return [String] code point in Unicode format
+    # @example
+    #   Unisec::Properties.intcp2stdhexcp(128640) # => "U+1F680"
+    def self.deccp2stdhexcp(int_cp)
+      "U+#{format('%.4x', int_cp).upcase}"
+    end
   end
 end

data/lib/unisec/rugrep.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'twitter_cldr'
+require 'paint'
+
+module Unisec
+  # Ruby grep : Ruby regular expression search for Unicode code point names
+  class Rugrep
+    # UCD Derived names file location
+    # @see https://www.unicode.org/Public/UCD/latest/ucd/extracted/DerivedName.txt
+    UCD_DERIVEDNAME = File.join(__dir__, '../../data/DerivedName.txt')
+
+    # Search code points by (Ruby) regexp
+    # @param regexp [Regexp] Regular expression without delimiters or modifiers.
+    #   Supports everything Ruby Regexp supports
+    # @return [Array<Hash>] Array of code points (`{char: String, codepoint: Integer, name: String}`)
+    # @example
+    #   Unisec::Rugrep.regrep('snowman|snowflake')
+    #   # =>
+    #   # [{:char=>"☃", :codepoint=>9731, :name=>"SNOWMAN"},
+    #   #  {:char=>"⛄", :codepoint=>9924, :name=>"SNOWMAN WITHOUT SNOW"},
+    #   #  {:char=>"⛇", :codepoint=>9927, :name=>"BLACK SNOWMAN"},
+    #   #  {:char=>"❄", :codepoint=>10052, :name=>"SNOWFLAKE"},
+    #   #  {:char=>"❅", :codepoint=>10053, :name=>"TIGHT TRIFOLIATE SNOWFLAKE"},
+    #   #  {:char=>"❆", :codepoint=>10054, :name=>"HEAVY CHEVRON SNOWFLAKE"}]
+    #   Unisec::Rugrep.regrep('greek small letter \w+')
+    #   # =>
+    #   # [{:char=>"ͱ", :codepoint=>881, :name=>"GREEK SMALL LETTER HETA"},
+    #   #  {:char=>"ͳ", :codepoint=>883, :name=>"GREEK SMALL LETTER ARCHAIC SAMPI"},
+    #   #  {:char=>"ͷ", :codepoint=>887, :name=>"GREEK SMALL LETTER PAMPHYLIAN DIGAMMA"},
+    #   #  …]
+    def self.regrep(regexp)
+      out = []
+      file = File.new(UCD_DERIVEDNAME)
+      file.each_line(chomp: true) do |line|
+        # Skip if the line is empty or a comment
+        next if line.empty? || line[0] == '#'
+
+        # parse the line to extract code point as integer and the name
+        cp_int, name = line.split(';')
+        cp_int = cp_int.chomp.to_i(16)
+        name.lstrip!
+        next unless /#{regexp}/i.match?(name) # compiling regexp once is surprisingly not faster
+
+        out << {
+          char: TwitterCldr::Utils::CodePoints.to_string([cp_int]),
+          codepoint: cp_int,
+          name: name
+        }
+      end
+      out
+    end
+
+    # Display a CLI-friendly output listing all code points corresponding to a regular expression.
+    # @example
+    #   Unisec::Rugrep.regrep_display('snowman|snowflake')
+    #   # =>
+    #   # U+2603  ☃    SNOWMAN
+    #   # U+26C4  ⛄    SNOWMAN WITHOUT SNOW
+    #   # U+26C7  ⛇    BLACK SNOWMAN
+    #   # U+2744  ❄    SNOWFLAKE
+    #   # U+2745  ❅    TIGHT TRIFOLIATE SNOWFLAKE
+    #   # U+2746  ❆    HEAVY CHEVRON SNOWFLAKE
+    def self.regrep_display(regexp)
+      codepoints = regrep(regexp)
+      codepoints.each do |cp|
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+      end
+      nil
+    end
+
+    # Returns the version of Unicode used in UCD local file (data/DerivedName.txt)
+    # @return [String] Unicode version
+    # @example
+    #   Unisec::Rugrep.ucd_derivedname_version # => "15.1.0"
+    def self.ucd_derivedname_version
+      first_line = File.open(UCD_DERIVEDNAME, &:readline)
+      first_line.match(/-(\d+\.\d+\.\d+)\.txt/).captures.first
+    end
+
+    # Search code points by (Ruby) regexp
+    # @param regexp [Regexp] Regular expression without delimiters or modifiers
+    # @return [Array<Hash>] Array of code points (`{char: String, codepoint: Integer, name: String}`)
+    # @example
+    #   Unisec::Rugrep.regrep_slow('snowman|snowflake')
+    #   # =>
+    #   # [{:char=>"☃", :codepoint=>9731, :name=>"SNOWMAN"},
+    #   #  {:char=>"⛄", :codepoint=>9924, :name=>"SNOWMAN WITHOUT SNOW"},
+    #   #  {:char=>"⛇", :codepoint=>9927, :name=>"BLACK SNOWMAN"},
+    #   #  {:char=>"❄", :codepoint=>10052, :name=>"SNOWFLAKE"},
+    #   #  {:char=>"❅", :codepoint=>10053, :name=>"TIGHT TRIFOLIATE SNOWFLAKE"},
+    #   #  {:char=>"❆", :codepoint=>10054, :name=>"HEAVY CHEVRON SNOWFLAKE"}]
+    # @note ⚠ This command is very time consuming (~ 1min) and unoptimized (execute one regexp per code point…)
+    def self.regrep_slow(regexp)
+      out = []
+      TwitterCldr::Shared::CodePoint.each do |cp|
+        next unless /#{regexp}/oi.match?(cp.name) # compiling regexp once is surprisingly not faster
+
+        out << {
+          char: TwitterCldr::Utils::CodePoints.to_string([cp.code_point]),
+          codepoint: cp.code_point,
+          name: cp.name
+        }
+      end
+      out
+    end
+
+    # Display a CLI-friendly output listing all code points corresponding to a regular expression.
+    # @example
+    #   Unisec::Rugrep.regrep_display_slow('snowman|snowflake')
+    #   # =>
+    #   # U+2603  ☃    SNOWMAN
+    #   # U+26C4  ⛄    SNOWMAN WITHOUT SNOW
+    #   # U+26C7  ⛇    BLACK SNOWMAN
+    #   # U+2744  ❄    SNOWFLAKE
+    #   # U+2745  ❅    TIGHT TRIFOLIATE SNOWFLAKE
+    #   # U+2746  ❆    HEAVY CHEVRON SNOWFLAKE
+    def self.regrep_display_slow(regexp)
+      codepoints = regrep_slow(regexp)
+      codepoints.each do |cp|
+        puts "#{Properties.deccp2stdhexcp(cp[:codepoint]).ljust(7)} #{cp[:char].ljust(4)} #{cp[:name]}"
+      end
+      nil
+    end
+  end
+end

data/lib/unisec/size.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'paint'
+
+module Unisec
+  # All kinf of size information about a Unicode string
+  class Size
+    # Number of code points
+    # @return [Integer] number of code points
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.code_points_size # => 6
+    attr_reader :code_points_size
+
+    # Number of graphemes
+    # @return [Integer] number of graphemes
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.grapheme_size # => 1
+    attr_reader :grapheme_size
+
+    # UTF-8 size in bytes
+    # @return [Integer] UTF-8 size in bytes
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf8_bytesize # => 20
+    attr_reader :utf8_bytesize
+
+    # UTF-16 size in bytes
+    # @return [Integer] UTF-16 size in bytes
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf16_bytesize # => 16
+    attr_reader :utf16_bytesize
+
+    # UTF-32 size in bytes
+    # @return [Integer] UTF-32 size in bytes
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf32_bytesize # => 24
+    attr_reader :utf32_bytesize
+
+    # Number of UTF-8 units
+    # @return [Integer] number of UTF-8 units
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf8_unitsize # => 20
+    attr_reader :utf8_unitsize
+
+    # Number of UTF-16 units
+    # @return [Integer] number of UTF-16 units
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf16_unitsize # => 8
+    attr_reader :utf16_unitsize
+
+    # Number of UTF-32 units
+    # @return [Integer] number of UTF-32 units
+    # @example
+    #   us = Unisec::Size.new('👩‍❤️‍👩')
+    #   us.utf32_unitsize # => 6
+    attr_reader :utf32_unitsize
+
+    def initialize(str)
+      @code_points_size = Size.code_points_size(str)
+      @grapheme_size = Size.grapheme_size(str)
+      @utf8_bytesize = Size.utf8_bytesize(str)
+      @utf16_bytesize = Size.utf16_bytesize(str)
+      @utf32_bytesize = Size.utf32_bytesize(str)
+      @utf8_unitsize = Size.utf8_unitsize(str)
+      @utf16_unitsize = Size.utf16_unitsize(str)
+      @utf32_unitsize = Size.utf32_unitsize(str)
+    end
+
+    # Number of code points
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] number of code points
+    # @example
+    #   Unisec::Size.code_points_size('👩‍❤️‍👩') # => 6
+    def self.code_points_size(str)
+      str.size
+    end
+
+    # Number of graphemes
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] number of graphemes
+    # @example
+    #   Unisec::Size.grapheme_size('👩‍❤️‍👩') # => 1
+    def self.grapheme_size(str)
+      str.grapheme_clusters.size
+    end
+
+    # UTF-8 size in bytes
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] UTF-8 size in bytes
+    # @example
+    #   Unisec::Size.utf8_bytesize('👩‍❤️‍👩') # => 20
+    def self.utf8_bytesize(str)
+      str.bytesize
+    end
+
+    # UTF-16 size in bytes
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] UTF-16 size in bytes
+    # @example
+    #   Unisec::Size.utf16_bytesize('👩‍❤️‍👩') # => 16
+    def self.utf16_bytesize(str)
+      str.encode('UTF-16BE').bytesize
+    end
+
+    # UTF-32 size in bytes
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] UTF-32 size in bytes
+    # @example
+    #   Unisec::Size.utf32_bytesize('👩‍❤️‍👩') # => 24
+    def self.utf32_bytesize(str)
+      str.encode('UTF-32BE').bytesize
+    end
+
+    # Number of UTF-8 units
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] number of UTF-8 units
+    # @example
+    #   Unisec::Size.utf8_unitsize('👩‍❤️‍👩') # => 20
+    def self.utf8_unitsize(str)
+      utf8_bytesize(str)
+    end
+
+    # Number of UTF-16 units
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] number of UTF-16 units
+    # @example
+    #   Unisec::Size.utf16_unitsize('👩‍❤️‍👩') # => 8
+    def self.utf16_unitsize(str)
+      utf16_bytesize(str) / 2
+    end
+
+    # Number of UTF-32 units
+    # @param str [String] Input sting we want to know the size of
+    # @return [Integer] number of UTF-32 units
+    # @example
+    #   Unisec::Size.utf32_unitsize('👩‍❤️‍👩') # => 6
+    def self.utf32_unitsize(str)
+      utf32_bytesize(str) / 4
+    end
+
+    # Display a CLI-friendly output summurizing the size information about a Unicode string.
+    # @example
+    #   Unisec::Size.new('👩‍❤️‍👨').display
+    #   # =>
+    #   # Code point(s):   6
+    #   # Grapheme(s):     1
+    #   # UTF-8 byte(s):   20
+    #   # UTF-16 byte(s):  16
+    #   # UTF-32 byte(s):  24
+    #   # UTF-8 unit(s):   20
+    #   # UTF-16 unit(s):  8
+    #   # UTF-32 unit(s):  6
+    def display
+      display = ->(key, value) { puts Paint[key, :red, :bold].ljust(27) + " #{value}" }
+      display.call('Code point(s):', @code_points_size)
+      display.call('Grapheme(s):', @grapheme_size)
+      display.call('UTF-8 byte(s):', @utf8_bytesize)
+      display.call('UTF-16 byte(s):', @utf16_bytesize)
+      display.call('UTF-32 byte(s):', @utf32_bytesize)
+      display.call('UTF-8 unit(s):', @utf8_unitsize)
+      display.call('UTF-16 unit(s):', @utf16_unitsize)
+      display.call('UTF-32 unit(s):', @utf32_unitsize)
+    end
+  end
+end

data/lib/unisec/version.rb

@@ -2,5 +2,5 @@
 
 module Unisec
   # Version of unisec library and app
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/lib/unisec/versions.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'twitter_cldr'
+require 'unicode/confusable'
+require 'paint'
+
+module Unisec
+  # Version information related to Unicode used in Unisec
+  class Versions
+    # Version and label of anything related to Unicode used in Unisec
+    # @return [Hash] versions of each component
+    # @example
+    #   Unisec::Versions.versions
+    #   # =>
+    #   # {:unisec=>{:version=>"0.0.1", :label=>"unisec"},
+    #   #  … }
+    def self.versions # rubocop:disable Metrics/MethodLength
+      {
+        unisec: {
+          version: Unisec::VERSION,
+          label: 'unisec'
+        },
+        ruby_unicode: {
+          version: RbConfig::CONFIG['UNICODE_VERSION'],
+          label: 'Unicode (Ruby)'
+        },
+        ruby_unicode_emoji: {
+          version: RbConfig::CONFIG['UNICODE_EMOJI_VERSION'],
+          label: 'Unicode emoji (Ruby)'
+        },
+        twittercldr_cldr: {
+          version: TwitterCldr::Versions::CLDR_VERSION,
+          label: 'CLDR (twitter_cldr gem)'
+        },
+        twittercldr_icu: {
+          version: TwitterCldr::Versions::ICU_VERSION,
+          label: 'ICU (twitter_cldr gem)'
+        },
+        twittercldr_unicode: {
+          version: TwitterCldr::Versions::UNICODE_VERSION,
+          label: 'Unicode (twitter_cldr gem)'
+        },
+        twittercldr: {
+          version: TwitterCldr::VERSION,
+          label: 'twitter_cldr gem'
+        },
+        unicodeconfusable: {
+          version: Unicode::Confusable::VERSION,
+          label: 'unicode-confusable gem'
+        },
+        unicodeconfusable_unicode: {
+          version: Unicode::Confusable::UNICODE_VERSION,
+          label: 'Unicode (unicode-confusable gem)'
+        },
+        ucd_derivedname: {
+          version: Unisec::Rugrep.ucd_derivedname_version,
+          label: 'UCD (data/DerivedName.txt)'
+        }
+      }
+    end
+
+    # Display a CLI-friendly output of the version of anything related to Unicode used in unisec
+    # @example
+    #   Unisec::Versions.display
+    #   # =>
+    #   # Unicode:
+    #   # Unicode (Ruby)                    15.0.0
+    #   # …
+    #   #
+    #   # Gems:
+    #   # unisec                            0.0.1
+    #   # …
+    def self.display # rubocop:disable Metrics/AbcSize
+      data = versions
+      display = ->(node) { puts Paint[data[node][:label], :red, :bold].ljust(44) + " #{data[node][:version]}" }
+      puts Paint['Unicode:', :underline]
+      display.call(:ruby_unicode)
+      display.call(:twittercldr_unicode)
+      display.call(:unicodeconfusable_unicode)
+      display.call(:twittercldr_icu)
+      display.call(:twittercldr_cldr)
+      display.call(:ruby_unicode_emoji)
+      display.call(:ucd_derivedname)
+      puts Paint["\nGems:", :underline]
+      display.call(:unisec)
+      display.call(:twittercldr)
+      display.call(:unicodeconfusable)
+    end
+  end
+end

data/lib/unisec.rb

@@ -2,7 +2,10 @@
 
 require 'unisec/version'
 
-require 'unisec/surrogates'
+require 'unisec/confusables'
 require 'unisec/hexdump'
 require 'unisec/properties'
-require 'unisec/confusables'
+require 'unisec/rugrep'
+require 'unisec/size'
+require 'unisec/surrogates'
+require 'unisec/versions'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unisec
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Alexandre ZANNI
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-21 00:00:00.000000000 Z
+date: 2023-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ctf-party
@@ -86,7 +86,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.9'
-description: Toolkit for security research manipulating Unicode
+description: 'Toolkit for security research manipulating Unicode: confusables, homoglyphs,
+  hexdump, code point, UTF-8, UTF-16, UTF-32, properties, regexp search, size, grapheme,
+  surrogates, version, ICU, CLDR, UCD'
 email: alexandre.zanni@europe.com
 executables:
 - unisec
@@ -95,18 +97,25 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - bin/unisec
+- data/DerivedName.txt
 - lib/unisec.rb
 - lib/unisec/cli/cli.rb
 - lib/unisec/cli/confusables.rb
 - lib/unisec/cli/hexdump.rb
 - lib/unisec/cli/properties.rb
+- lib/unisec/cli/rugrep.rb
+- lib/unisec/cli/size.rb
 - lib/unisec/cli/surrogates.rb
+- lib/unisec/cli/versions.rb
 - lib/unisec/confusables.rb
 - lib/unisec/hexdump.rb
 - lib/unisec/properties.rb
+- lib/unisec/rugrep.rb
+- lib/unisec/size.rb
 - lib/unisec/surrogates.rb
 - lib/unisec/utils.rb
 - lib/unisec/version.rb
+- lib/unisec/versions.rb
 homepage: https://github.com/Acceis/unisec
 licenses:
 - MIT
@@ -136,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
 summary: Unicode Security Toolkit