schemurai 3.0.1 → 3.0.2

data/lib/schemurai/vm/evaluator.rb

@@ -1,84 +1,62 @@
 # frozen_string_literal: true
 
+require_relative "../decimal"
 require "base64"
 require "json"
-require "set" # rubocop:disable Lint/RedundantRequireStatement -- Required on Ruby 3.4.
+require_relative "../evaluation_pool"
 require_relative "../evaluation"
 require_relative "../error_message"
 require_relative "../unique_items"
+require_relative "../value_equality"
+require_relative "../container_checks"
+require_relative "../ecma_regexp"
+require_relative "../json_pointer"
 require_relative "compiler"
+require_relative "../string_checks"
 
 module Schemurai
   module VM
-    class EvaluationBuffer
-      attr_reader :evaluated_properties, :evaluated_items
-
-      def initialize
-        # Applicators can overlap. Array membership makes collecting and merging
-        # their annotations quadratic in the number of instance locations.
-        @evaluated_properties = Set.new
-        @evaluated_items = Set.new
-      end
-
-      def valid? = true
-
-      def reset
-        @evaluated_properties.clear
-        @evaluated_items.clear
-        self
-      end
-
-      def record_property(name)
-        @evaluated_properties.add(name)
-        self
-      end
-
-      def record_item(index)
-        @evaluated_items.add(index)
-        self
-      end
-
-      def merge(other)
-        return Evaluation.invalid unless other.valid?
-
-        properties = other.evaluated_properties
-        items = other.evaluated_items
-        @evaluated_properties.merge(properties) unless properties.empty?
-        @evaluated_items.merge(items) unless items.empty?
-        self
-      end
-    end
+    EvaluationBuffer = Internal::EvaluationBuffer
     private_constant :EvaluationBuffer
 
     class Evaluator
       include Internal::UniqueItems
-
-      MISSING_SEGMENT = Object.new.freeze
-      DECIMAL_CACHE_LIMIT = 16
+      include Internal::ValueEquality
+      include Internal::ContainerChecks::Bounds
+      include Internal::ContainerChecks::ObjectChildren
+      include Internal::ContainerChecks::ArrayChildren
+      include Internal::ContainerChecks::ArrayDiagnostics
+      include Internal::ContainerChecks::ObjectDiagnostics
+      include Internal::NumberChecks::Evaluation
+      include Internal::StringChecks::Evaluation
+      include Internal::StringChecks::Regexps
+
+      MISSING_SEGMENT = Internal::ContainerChecks::ObjectDiagnostics::MISSING_SEGMENT
 
       def backend = :vm
 
-      def initialize(graph, compiler, root, content: false, format: false)
+      def initialize(graph, compiler, root, content: false, format: false, number_state: nil, regexps: nil, dynamic_scope: nil, active_state: nil, native_references: nil, native_reports: nil)
         @graph = graph
         @compiler = compiler
         @root = root
         @validate_content = content
         @validate_format = format
-        @regexps = nil
-        @active = nil
+        @regexps = regexps
+        @active = active_state
+        @native_reports = native_reports
+        @native_references = native_references
         @resolved_references = nil
-        @decimals = nil
-        @multiple_results = nil
-        @dynamic_scope = nil
+        @number_state = number_state
+        @dynamic_scope = dynamic_scope
         @instance_path_buffer = nil
         @schema_path_buffer = nil
-        @evaluation_pool = nil
-        @evaluation_pool_index = 0
+        @evaluation_pool = native_reports ? native_reports[1] : Internal::EvaluationPool.new
       end
 
       def validate(instance)
         @errors = []
         prepare_evaluation(paths: true)
+        @native_reports[0] = self if @native_reports
         evaluate(@root, instance)
         Result.new(@errors)
       ensure
@@ -92,9 +70,37 @@ module Schemurai
         @instance_path = nil
         @schema_path = nil
         reset_evaluation_pool
+        @native_reports[0] = self if @native_reports
         evaluate_valid(@root, instance)
       end
 
+      # Data exchange for retained native blocks during a compatibility traversal.
+      # These methods expose collection state, never programs or instructions.
+      private def native_report_context
+        [@errors, @error_count || 0, @instance_path, @schema_path]
+      end
+
+      private def native_clear_collection(paths = false)
+        @errors = nil
+        @error_count = 0
+        if paths
+          (@instance_path_buffer ||= []).clear
+          (@schema_path_buffer ||= []).clear
+          @instance_path = @instance_path_buffer
+          @schema_path = @schema_path_buffer
+        else
+          @instance_path = nil
+          @schema_path = nil
+        end
+      end
+
+      private def native_append_report(errors, count, reset)
+        native_clear_collection(reset == 2) unless reset.zero?
+        @error_count += count
+        @errors.concat(errors) if @errors
+        @native_reports[0] = self
+      end
+
       private def prepare_evaluation(paths:)
         @error_count = 0
         @dynamic_scope&.clear
@@ -142,19 +148,19 @@ module Schemurai
             target = dynamic_target(program, operand)
             return false unless valid_reference?(program, target, instance)
           when :type_null
-            return false unless instance.nil?
+            return false unless Internal::TypeChecks.single?(instance, TYPE_NULL)
           when :type_boolean
-            return false unless instance == true || instance == false
+            return false unless Internal::TypeChecks.single?(instance, TYPE_BOOLEAN)
           when :type_object
-            return false unless instance.is_a?(Hash)
+            return false unless Internal::TypeChecks.single?(instance, TYPE_OBJECT)
           when :type_array
-            return false unless instance.is_a?(Array)
+            return false unless Internal::TypeChecks.single?(instance, TYPE_ARRAY)
           when :type_number
-            return false unless instance.is_a?(Numeric) && !instance.is_a?(Complex)
+            return false unless Internal::TypeChecks.single?(instance, TYPE_NUMBER)
           when :type_integer
-            return false unless instance.is_a?(Numeric) && !instance.is_a?(Complex) && instance.finite? && instance.to_i == instance
+            return false unless Internal::TypeChecks.single?(instance, TYPE_INTEGER)
           when :type_string
-            return false unless instance.is_a?(String)
+            return false unless Internal::TypeChecks.single?(instance, TYPE_STRING)
           when :typed_number
             return false unless instance.is_a?(Numeric) && !instance.is_a?(Complex) && valid_number?(operand, instance)
           when :typed_integer
@@ -213,14 +219,11 @@ module Schemurai
       end
 
       private def reset_evaluation_pool
-        @evaluation_pool_index = 0
+        @evaluation_pool.reset
       end
 
       private def tracked_evaluation
-        pool = (@evaluation_pool ||= [])
-        index = @evaluation_pool_index
-        @evaluation_pool_index += 1
-        (pool[index] ||= EvaluationBuffer.new).reset
+        @evaluation_pool.acquire
       end
 
       private def evaluate(program, instance)
@@ -254,21 +257,21 @@ module Schemurai
           when :dynamic_ref
             evaluation = evaluation.merge(evaluate_dynamic_ref(program, operand, instance))
           when :type_null
-            check_compiled_type("null", instance.nil?, instance)
+            check_compiled_type("null", Internal::TypeChecks.single?(instance, TYPE_NULL), instance)
           when :type_boolean
-            check_compiled_type("boolean", instance == true || instance == false, instance)
+            check_compiled_type("boolean", Internal::TypeChecks.single?(instance, TYPE_BOOLEAN), instance)
           when :type_object
-            check_compiled_type("object", instance.is_a?(Hash), instance)
+            check_compiled_type("object", Internal::TypeChecks.single?(instance, TYPE_OBJECT), instance)
           when :type_array
-            check_compiled_type("array", instance.is_a?(Array), instance)
+            check_compiled_type("array", Internal::TypeChecks.single?(instance, TYPE_ARRAY), instance)
           when :type_number
-            check_compiled_type("number", number?(instance), instance)
+            check_compiled_type("number", Internal::TypeChecks.single?(instance, TYPE_NUMBER), instance)
           when :type_integer
-            check_compiled_type("integer", integer?(instance), instance)
+            check_compiled_type("integer", Internal::TypeChecks.single?(instance, TYPE_INTEGER), instance)
           when :type_string
-            check_compiled_type("string", instance.is_a?(String), instance)
+            check_compiled_type("string", Internal::TypeChecks.single?(instance, TYPE_STRING), instance)
           when :typed_number
-            if number?(instance)
+            if instance.is_a?(Numeric) && !instance.is_a?(Complex)
               check_number(operand, instance)
             else
               check_compiled_type("number", false, instance)
@@ -372,7 +375,7 @@ module Schemurai
 
       private def valid_reference?(source, target, instance)
         instances = active_instances(source)
-        return true if instances.key?(instance)
+        return true if instances.key?(instance) || @native_references&.reference_active?(source, instance)
 
         instances[instance] = true
         activated = true
@@ -407,7 +410,7 @@ module Schemurai
 
       private def evaluate_reference(source, target, instance, keyword)
         instances = active_instances(source)
-        return Evaluation.valid if instances.key?(instance)
+        return Evaluation.valid if instances.key?(instance) || @native_references&.reference_active?(source, instance)
 
         instances[instance] = true
         activated = true
@@ -438,36 +441,16 @@ module Schemurai
       end
 
       private def instance_type_mask(value, integer:)
-        return TYPE_NULL if value.nil?
-        return TYPE_BOOLEAN if value == true || value == false
-        return TYPE_OBJECT if value.is_a?(Hash)
-        return TYPE_ARRAY if value.is_a?(Array)
-        return TYPE_STRING if value.is_a?(String)
-        return 0 unless number?(value)
-        return TYPE_NUMBER unless integer
-
-        (value.finite? && value.to_i == value) ? TYPE_NUMBER | TYPE_INTEGER : TYPE_NUMBER
+        Internal::TypeChecks.instance_mask(value, integer: integer)
       end
 
       private def integer?(value)
-        number?(value) && value.finite? && value.to_i == value
-      end
-
-      private def valid_number?(rules, value)
-        mask = rules.mask
-        actual = (mask & MULTIPLE_OF).zero? ? value : decimal(value)
-        return false if (mask & MAXIMUM) != 0 && actual > rules.maximum
-        return false if (mask & MINIMUM) != 0 && actual < rules.minimum
-        return false if (mask & EXCLUSIVE_MAXIMUM) != 0 && actual >= rules.exclusive_maximum
-        return false if (mask & EXCLUSIVE_MINIMUM) != 0 && actual <= rules.exclusive_minimum
-        return true if (mask & MULTIPLE_OF).zero?
-
-        valid_multiple?(rules, value)
+        Internal::TypeChecks.integer?(value)
       end
 
       private def check_number(rules, value)
         mask = rules.mask
-        actual = (mask & MULTIPLE_OF).zero? ? value : decimal(value)
+        actual = (mask & MULTIPLE_OF).zero? ? value : number_state.decimal(value)
         if (mask & MAXIMUM) != 0 && actual > rules.maximum
           add_error("maximum") { Internal::ErrorMessage.numeric_limit("maximum", rules.maximum) }
         end
@@ -491,33 +474,6 @@ module Schemurai
         add_error("multipleOf") { Internal::ErrorMessage.multiple_of(divisor) } unless valid
       end
 
-      private def valid_multiple?(rules, value)
-        results = (@multiple_results ||= {}.compare_by_identity)
-        values = (results[rules] ||= {})
-        return values[value] if values.key?(value)
-
-        values.clear if values.length >= DECIMAL_CACHE_LIMIT
-        divisor = rules.multiple_of
-        values[value] = divisor.positive? && decimal(value).remainder(divisor).zero?
-      end
-
-      private def valid_string?(rules, value)
-        length = value.length
-        return false if rules.max_length && length > rules.max_length
-        return false if rules.min_length && length < rules.min_length
-        return false if rules.pattern && !ecma_regexp(rules.pattern).match?(value)
-        if rules.format && (@validate_format || rules.format_assertion)
-          return false unless rules.format.call(value)
-        end
-        if @validate_content && (rules.decode_base64 || rules.parse_json)
-          return valid_content?(rules, value)
-        end
-
-        true
-      rescue RegexpError, IPAddr::InvalidAddressError
-        false
-      end
-
       private def check_string(rules, value)
         length = value.length
         if rules.max_length && length > rules.max_length
@@ -537,14 +493,6 @@ module Schemurai
         add_error("pattern") { Internal::ErrorMessage.invalid_pattern(rules.pattern) }
       end
 
-      private def valid_content?(rules, value)
-        decoded = rules.decode_base64 ? Base64.strict_decode64(value) : value
-        JSON.parse(decoded) if rules.parse_json
-        true
-      rescue ArgumentError, JSON::ParserError
-        false
-      end
-
       private def check_content(rules, value)
         decoded = rules.decode_base64 ? Base64.strict_decode64(value) : value
         return unless rules.parse_json
@@ -559,347 +507,18 @@ module Schemurai
 
       private def valid_array?(rules, value)
         length = value.length
-        return false if rules.max_items && length > rules.max_items
-        return false if rules.min_items && length < rules.min_items
+        return false unless valid_container_bounds?(length, rules.max_items, rules.min_items)
         return false if rules.unique && !unique_items?(value)
 
-        if (prefix_items = rules.prefix_items)
-          prefix_items.each_with_index do |child, index|
-            @budget&.checkpoint
-            break if index >= length
-            return false unless evaluate_valid(child, value[index])
-          end
-        end
-
-        items = rules.items
-        if rules.items_list
-          items.each_with_index do |child, index|
-            @budget&.checkpoint
-            break if index >= length
-            return false unless evaluate_valid(child, value[index])
-          end
-          if length > items.length && (additional = rules.additional)
-            index = items.length
-            while index < length
-              @budget&.checkpoint
-              return false unless evaluate_valid(additional, value[index])
-              index += 1
-            end
-          end
-        elsif items
-          start = rules.prefix_items&.length || 0
-          index = start
-          while index < length
-            @budget&.checkpoint
-            return false unless evaluate_valid(items, value[index])
-            index += 1
-          end
-        end
-
-        if (contains = rules.contains)
-          if rules.count_contains
-            matches = value.count { |item| evaluate_valid(contains, item) }
-            return false if matches < rules.min_contains || matches > rules.max_contains
-          else
-            return false unless value.any? { |item| evaluate_valid(contains, item) }
-          end
-        end
-        true
-      end
-
-      private def check_array(rules, value, prior_evaluation)
-        evaluation = nil
-        if rules.max_items && value.length > rules.max_items
-          return Evaluation.invalid unless @errors
-
-          add_error("maxItems") { Internal::ErrorMessage.size("maxItems", rules.max_items, value.length) }
-        end
-        if rules.min_items && value.length < rules.min_items
-          return Evaluation.invalid unless @errors
-
-          add_error("minItems") { Internal::ErrorMessage.size("minItems", rules.min_items, value.length) }
-        end
-        if rules.unique && !unique_items?(value)
-          return Evaluation.invalid unless @errors
-
-          add_error("uniqueItems") { Internal::ErrorMessage.unique_items }
-        end
-
-        if (prefix_items = rules.prefix_items)
-          prefix_items.each_with_index do |child, index|
-            @budget&.checkpoint
-            break if index >= value.length
-            valid = evaluate_child_at(child, value[index], index, "prefixItems", index)
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_item(index)
-          end
-        end
-
-        items = rules.items
-        if rules.items_list
-          items.each_with_index do |child, index|
-            @budget&.checkpoint
-            break if index >= value.length
-            valid = evaluate_child_at(child, value[index], index, "items", index)
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_item(index)
-          end
-          if value.length > items.length && (additional = rules.additional)
-            (items.length...value.length).each do |index|
-              @budget&.checkpoint
-              valid = evaluate_child_at(additional, value[index], index, "additionalItems")
-              return Evaluation.invalid if !valid && !@errors
-              (evaluation ||= tracked_evaluation).record_item(index)
-            end
-          end
-        elsif items
-          start = rules.prefix_items&.length || 0
-          (start...value.length).each do |index|
-            @budget&.checkpoint
-            valid = evaluate_child_at(items, value[index], index, "items")
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_item(index)
-          end
-        end
-
-        if (contains = rules.contains)
-          matched = nil
-          index = 0
-          while index < value.length
-            @budget&.checkpoint
-            (matched ||= []) << index if trial(contains, value[index]).valid?
-            index += 1
-          end
-          matched_count = matched ? matched.length : 0
-          unless matched_count.between?(rules.min_contains, rules.max_contains)
-            return Evaluation.invalid unless @errors
-
-            add_error("contains") do
-              Internal::ErrorMessage.contains(matched_count, rules.min_contains, rules.max_contains)
-            end
-          end
-          if matched
-            matched.each { |index| (evaluation ||= tracked_evaluation).record_item(index) }
-          end
-        end
-
-        if (unevaluated = rules.unevaluated)
-          prior_items = prior_evaluation.evaluated_items
-          index = 0
-          while index < value.length
-            @budget&.checkpoint
-            if prior_items.include?(index) || evaluation&.evaluated_items&.include?(index)
-              index += 1
-              next
-            end
-            valid = evaluate_child_at(unevaluated, value[index], index, "unevaluatedItems")
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_item(index)
-            index += 1
-          end
-        end
-        return Evaluation.valid unless evaluation
-
-        evaluation
+        valid_array_children?(rules, value, length) { |child, item| evaluate_valid(child, item) }
       end
 
       private def valid_object?(rules, value)
         length = value.length
-        return false if rules.max_properties && length > rules.max_properties
-        return false if rules.min_properties && length < rules.min_properties
-        if rules.required && !rules.required.all? do |name|
-          @budget&.checkpoint
-          value.key?(name)
-        end
-          return false
-        end
-
-        properties = rules.properties
-        patterns = rules.patterns
-        additional = rules.additional
-        unless properties.empty? && patterns.nil? && additional.nil?
-          value.each do |name, property_value|
-            @budget&.checkpoint
-            matched = false
-            if (child = properties[name])
-              matched = true
-              return false unless evaluate_valid(child, property_value)
-            end
-            if patterns
-              patterns.each do |pattern, child|
-                @budget&.checkpoint
-                next unless ecma_regexp(pattern).match?(name)
-                matched = true
-                return false unless evaluate_valid(child, property_value)
-              end
-            end
-            return false if !matched && additional && !evaluate_valid(additional, property_value)
-          end
-        end
-
-        if (property_names = rules.property_names)
-          value.each_key { |name| return false unless evaluate_valid(property_names, name) }
-        end
-        if (dependencies = rules.dependencies)
-          dependencies.each do |name, dependency|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            if dependency.is_a?(Array)
-              return false unless dependency.all? do |required_name|
-                @budget&.checkpoint
-                value.key?(required_name)
-              end
-            else
-              return false unless evaluate_valid(dependency, value)
-            end
-          end
-        end
-        if (dependent_required = rules.dependent_required)
-          dependent_required.each do |name, required_names|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            return false unless required_names.all? do |required_name|
-              @budget&.checkpoint
-              value.key?(required_name)
-            end
-          end
-        end
-        if (dependent_schemas = rules.dependent_schemas)
-          dependent_schemas.each do |name, child|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            return false unless evaluate_valid(child, value)
-          end
-        end
-        true
-      end
-
-      private def check_object(rules, value, prior_evaluation)
-        evaluation = nil
-        if rules.max_properties && value.length > rules.max_properties
-          return Evaluation.invalid unless @errors
-
-          add_error("maxProperties") do
-            Internal::ErrorMessage.size("maxProperties", rules.max_properties, value.length)
-          end
-        end
-        if rules.min_properties && value.length < rules.min_properties
-          return Evaluation.invalid unless @errors
-
-          add_error("minProperties") do
-            Internal::ErrorMessage.size("minProperties", rules.min_properties, value.length)
-          end
-        end
-        if (required = rules.required)
-          required.each do |name|
-            @budget&.checkpoint
-            next if value.key?(name)
-            return Evaluation.invalid unless @errors
-
-            add_error("required") { Internal::ErrorMessage.required(name) }
-          end
-        end
-
-        properties = rules.properties
-        patterns = rules.patterns
-        value.each do |name, property_value|
-          @budget&.checkpoint
-          matched = false
-          if (child = properties[name])
-            matched = true
-            valid = evaluate_child_at(child, property_value, name, "properties", name)
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_property(name)
-          end
-          if patterns
-            patterns.each do |pattern, child|
-              @budget&.checkpoint
-              next unless ecma_regexp(pattern).match?(name)
-              matched = true
-              valid = evaluate_child_at(child, property_value, name, "patternProperties", pattern)
-              return Evaluation.invalid if !valid && !@errors
-              (evaluation ||= tracked_evaluation).record_property(name)
-            end
-          end
-          if !matched && (additional = rules.additional)
-            valid = evaluate_child_at(additional, property_value, name, "additionalProperties")
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_property(name)
-          end
-        end
-
-        if (property_names = rules.property_names)
-          value.each_key do |name|
-            @budget&.checkpoint
-            valid = evaluate_child_at(property_names, name, name, "propertyNames")
-            return Evaluation.invalid if !valid && !@errors
-          end
-        end
-        if (dependencies = rules.dependencies)
-          dependencies.each do |name, dependency|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            if dependency.is_a?(Array)
-              dependency.each do |required_name|
-                @budget&.checkpoint
-                unless value.key?(required_name)
-                  return Evaluation.invalid unless @errors
-
-                  add_error("dependencies") { Internal::ErrorMessage.dependent_required(name, required_name) }
-                end
-              end
-            else
-              result = evaluate_at(dependency, value, MISSING_SEGMENT, "dependencies", name)
-              if result.valid? && !result.evaluated_properties.empty?
-                result.evaluated_properties.each do |property|
-                  @budget&.checkpoint
-                  (evaluation ||= tracked_evaluation).record_property(property)
-                end
-              end
-            end
-          end
-        end
-        if (dependent_required = rules.dependent_required)
-          dependent_required.each do |name, required_names|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            required_names.each do |required_name|
-              @budget&.checkpoint
-              unless value.key?(required_name)
-                return Evaluation.invalid unless @errors
-
-                add_error("dependentRequired") { Internal::ErrorMessage.dependent_required(name, required_name) }
-              end
-            end
-          end
-        end
-        if (dependent_schemas = rules.dependent_schemas)
-          dependent_schemas.each do |name, child|
-            @budget&.checkpoint
-            next unless value.key?(name)
-            result = evaluate_at(child, value, MISSING_SEGMENT, "dependentSchemas", name)
-            if result.valid? && !result.evaluated_properties.empty?
-              result.evaluated_properties.each do |property|
-                @budget&.checkpoint
-                (evaluation ||= tracked_evaluation).record_property(property)
-              end
-            end
-          end
-        end
-        if (unevaluated = rules.unevaluated)
-          prior_properties = prior_evaluation.evaluated_properties
-          value.each_key do |name|
-            @budget&.checkpoint
-            next if prior_properties.include?(name) || evaluation&.evaluated_properties&.include?(name)
-
-            valid = evaluate_child_at(unevaluated, value[name], name, "unevaluatedProperties")
-            return Evaluation.invalid if !valid && !@errors
-            (evaluation ||= tracked_evaluation).record_property(name)
-          end
-        end
-        return Evaluation.valid unless evaluation
+        return false unless valid_container_bounds?(length, rules.max_properties, rules.min_properties)
+        return false unless valid_required_keys?(rules.required, value)
 
-        evaluation
+        valid_object_children?(rules, value) { |child, item| evaluate_valid(child, item) }
       end
 
       private def check_combiner(opcode, operand, value)
@@ -975,6 +594,7 @@ module Schemurai
       ensure
         @errors = saved_errors
         @error_count = saved_count
+        @native_reports[0] = self if @native_reports
         if saved_instance_path
           @instance_path = saved_instance_path
           @schema_path = saved_schema_path
@@ -1021,85 +641,7 @@ module Schemurai
       end
 
       private def number?(value)
-        value.is_a?(Numeric) && !value.is_a?(Complex)
-      end
-
-      private def json_equal?(left, right)
-        if left.is_a?(Numeric) && !left.is_a?(Complex)
-          return right.is_a?(Numeric) && !right.is_a?(Complex) && left == right
-        end
-        return false unless left.instance_of?(right.class)
-
-        case left
-        when Hash
-          left.length == right.length && left.all? do |key, value|
-            @budget&.checkpoint
-            right.key?(key) && json_equal?(value, right[key])
-          end
-        when Array
-          return false unless left.length == right.length
-
-          index = 0
-          while index < left.length
-            @budget&.checkpoint
-            return false unless json_equal?(left[index], right[index])
-            index += 1
-          end
-          true
-        else
-          left == right
-        end
-      end
-
-      private def decimal(value)
-        return value if value.is_a?(Integer) || value.is_a?(Rational)
-
-        decimals = (@decimals ||= {})
-        return decimals[value] if decimals.key?(value)
-
-        decimals.clear if decimals.length >= DECIMAL_CACHE_LIMIT
-        decimals[value] = Rational(value.to_s)
-      end
-
-      private def ecma_regexp(pattern)
-        regexps = (@regexps ||= {})
-        return regexps[pattern] if regexps.key?(pattern)
-
-        whitespace = "\\u0009-\\u000D\\u0020\\u00A0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF"
-        translated = +""
-        escaped = false
-        in_class = false
-        pattern.each_char do |character|
-          @budget&.checkpoint
-          if escaped
-            translated << case character
-            when "d" then in_class ? "0-9" : "[0-9]"
-            when "D" then in_class ? "^0-9" : "[^0-9]"
-            when "w" then in_class ? "A-Za-z0-9_" : "[A-Za-z0-9_]"
-            when "W" then in_class ? "^A-Za-z0-9_" : "[^A-Za-z0-9_]"
-            when "s" then in_class ? whitespace : "[#{whitespace}]"
-            when "S" then in_class ? "^#{whitespace}" : "[^#{whitespace}]"
-            else "\\#{character}"
-            end
-            escaped = false
-          elsif character == "\\"
-            escaped = true
-          elsif character == "["
-            in_class = true
-            translated << character
-          elsif character == "]"
-            in_class = false
-            translated << character
-          elsif character == "^" && !in_class
-            translated << "\\A"
-          elsif character == "$" && !in_class
-            translated << "\\z"
-          else
-            translated << character
-          end
-        end
-        translated << "\\" if escaped
-        regexps[pattern] = Regexp.new(translated)
+        Internal::TypeChecks.number?(value)
       end
 
       private def pointer(path, final_segment = MISSING_SEGMENT)
@@ -1110,10 +652,10 @@ module Schemurai
       end
 
       private def append_pointer_segment(pointer, segment)
-        pointer << "/" << segment.to_s.gsub("~", "~0").gsub("/", "~1")
+        pointer << "/" << Internal::JsonPointer.escape(segment)
       end
 
-      private_constant :DECIMAL_CACHE_LIMIT, :MISSING_SEGMENT
+      private_constant :MISSING_SEGMENT
     end
   end