# frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "erb"
          
        
      
        

          

            
              1
            

            
              
            

            require "set"
          
        
      
        

          

            
              1
            

            
              
            

            require "zeitwerk"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex
          
        
      
        

          

            
              1
            

            
              
            

            	Loader = Zeitwerk::Loader.for_gem.tap do |loader|
          
        
      
        

          

            
              1
            

            
              
            

            		loader.ignore("#{__dir__}/ruby_lsp")
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		loader.inflector.inflect(
          
        
      
        

          

            

            
              
            

            			"csv" => "CSV",
          
        
      
        

          

            

            
              
            

            			"fifo" => "FIFO",
          
        
      
        

          

            

            
              
            

            			"fifo_cache_store" => "FIFOCacheStore",
          
        
      
        

          

            

            
              
            

            			"html" => "HTML",
          
        
      
        

          

            

            
              
            

            			"sgml" => "SGML",
          
        
      
        

          

            

            
              
            

            			"svg" => "SVG",
          
        
      
        

          

            

            
              
            

            		)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		loader.collapse("#{__dir__}/phlex/errors")
          
        
      
        

          

            
              1
            

            
              
            

            		loader.setup
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	Escape = ERB::Escape
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	DEPLOYED_AT = Process.clock_gettime(Process::CLOCK_MONOTONIC, :millisecond)
          
        
      
        

          

            
              1
            

            
              
            

            	CACHED_FILES = Set.new
          
        
      
        

          

            
              1
            

            
              
            

            	ATTRIBUTE_CACHE = FIFO.new
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def self.__expand_attribute_cache__(file_path)
          
        
      
        

          

            
              694
            

            
              
                
                  else: 653
                
              
                
                  then: 41
                
              
            

            		unless CACHED_FILES.include?(file_path)
          
        
      
        

          

            
              41
            

            
              
            

            			CACHED_FILES << file_path
          
        
      
        

          

            
              41
            

            
              
            

            			Phlex::ATTRIBUTE_CACHE.expand(File.size(file_path))
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Generate an HTML string using Phlex’ HTML DSL
          
        
      
        

          

            
              1
            

            
              
            

            	def self.html(&block)
          
        
      
        

          

            
              2
            

            
              
            

            		HTML.call do |component|
          
        
      
        

          

            
              2
            

            
              
            

            			receiver = block.binding.receiver
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

            			receiver.instance_variables.each do |ivar|
          
        
      
        

          

            
              9
            

            
              
                
                  then: 0
                
              
                
                  else: 9
                
              
            

            				next if component.instance_variable_defined?(ivar)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              9
            

            
              
            

            				value = receiver.instance_variable_get(ivar)
          
        
      
        

          

            
              9
            

            
              
            

            				component.instance_variable_set(ivar, value)
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              2
            

            
              
            

            			component.instance_exec(receiver, &block)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Generate an SVG string using Phlex’ SVG DSL
          
        
      
        

          

            
              1
            

            
              
            

            	def self.svg(&block)
          
        
      
        

          

            

            
              
            

            		SVG.call do |component|
          
        
      
        

          

            

            
              
            

            			receiver = block.binding.receiver
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            			receiver.instance_variables.each do |ivar|
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

            				next if component.instance_variable_defined?(ivar)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				value = receiver.instance_variable_get(ivar)
          
        
      
        

          

            

            
              
            

            				component.instance_variable_set(ivar, value)
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            			component.instance_exec(receiver, &block)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            def 💪
          
        
      
        

          

            
              1
            

            
              
            

            	Phlex
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "prism"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Compiler
          
        
      
        

          

            
              1
            

            
              
            

            	Error = Class.new(StandardError)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def self.compile(component)
          
        
      
        

          

            
              11
            

            
              
            

            		path, line = Object.const_source_location(component.name)
          
        
      
        

          

            
              11
            

            
              
                
                  else: 11
                
              
                
                  then: 0
                
              
            

            		return unless File.exist?(path)
          
        
      
        

          

            
              11
            

            
              
            

            		source = File.read(path)
          
        
      
        

          

            
              11
            

            
              
            

            		tree = Prism.parse(source).value
          
        
      
        

          

            
              11
            

            
              
            

            		Compilation.new(component, path, line, source, tree).compile
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::Compiler::ClassCompiler < Prism::Visitor
          
        
      
        

          

            
              1
            

            
              
            

            	def initialize(compiler)
          
        
      
        

          

            
              11
            

            
              
            

            		@compiler = compiler
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def compile(node)
          
        
      
        

          

            
              11
            

            
              
            

            		visit_all(node.child_nodes)
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_def_node(node)
          
        
      
        

          

            
              14
            

            
              
                
                  then: 1
                
              
                
                  else: 13
                
              
            

            		return if node.name == :initialize
          
        
      
        

          

            
              13
            

            
              
                
                  then: 0
                
              
                
                  else: 13
                
              
            

            		return if node.receiver
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              13
            

            
              
            

            		compiled_source = Phlex::Compiler::MethodCompiler.new(@compiler.component).compile(node)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              13
            

            
              
                
                  else: 0
                
              
            

            		if compiled_source
          
        
      
        

          

            

            
              
                
                  then: 13
                
              
            

            			# puts compiled_source
          
        
      
        

          

            
              13
            

            
              
            

            			@compiler.redefine_method(compiled_source, node.location.start_line)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_class_node(node)
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_module_node(node)
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_block_node(node)
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Compiler
          
        
      
        

          

            
              1
            

            
              
            

            	class Compilation
          
        
      
        

          

            
              1
            

            
              
            

            		def initialize(component, path, line, source, tree)
          
        
      
        

          

            
              11
            

            
              
            

            			@component = component
          
        
      
        

          

            
              11
            

            
              
            

            			@path = path
          
        
      
        

          

            
              11
            

            
              
            

            			@line = line
          
        
      
        

          

            
              11
            

            
              
            

            			@source = source
          
        
      
        

          

            
              11
            

            
              
            

            			@tree = tree
          
        
      
        

          

            
              11
            

            
              
            

            			freeze
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		attr_reader :component, :line, :source, :path
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile
          
        
      
        

          

            
              11
            

            
              
            

            			FileCompiler.new(self).compile(@tree)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def redefine_method(source, line)
          
        
      
        

          

            
              13
            

            
              
            

            			@component.class_eval("# frozen_string_literal: true\n#{source}", @path, line - 1)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::Compiler::FileCompiler < Prism::Visitor
          
        
      
        

          

            
              1
            

            
              
            

            	def initialize(compiler)
          
        
      
        

          

            
              11
            

            
              
            

            		@compiler = compiler
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def compile(node)
          
        
      
        

          

            
              11
            

            
              
            

            		visit(node)
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_class_node(node)
          
        
      
        

          

            
              11
            

            
              
                
                  then: 11
                
              
                
                  else: 0
                
              
            

            		if @compiler.line == node.location.start_line
          
        
      
        

          

            
              11
            

            
              
            

            			Phlex::Compiler::ClassCompiler.new(@compiler).compile(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# def visit_module_node(node)
          
        
      
        

          

            

            
              
            

            	# 	super
          
        
      
        

          

            

            
              
            

            	# end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_def_node(node)
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def visit_block_node(node)
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Compiler
          
        
      
        

          

            
              1
            

            
              
            

            	class Formatter < VerbatimFormatter
          
        
      
        

          

            
              1
            

            
              
            

            		def visit(node)
          
        
      
        

          

            
              890
            

            
              
            

            			case node
          
        
      
        

          

            

            
              
                
                  when: 230
                
              
            

            			when nil
          
        
      
        

          

            
              230
            

            
              
            

            				nil
          
        
      
        

          

            

            
              
                
                  when: 157
                
              
            

            			when String
          
        
      
        

          

            
              157
            

            
              
            

            				push node
          
        
      
        

          

            

            
              
                
                  when: 229
                
              
            

            			when Array, Set
          
        
      
        

          

            
              816
            

            
              
            

            				node.each { |n| visit(n) }
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

            			when Proc
          
        
      
        

          

            

            
              
            

            				visit node.call
          
        
      
        

          

            

            
              
                
                  when: 88
                
              
            

            			when :new_line
          
        
      
        

          

            
              88
            

            
              
            

            				new_line
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

            			when :space
          
        
      
        

          

            

            
              
            

            				space
          
        
      
        

          

            

            
              
                
                  else: 186
                
              
            

            			else
          
        
      
        

          

            
              186
            

            
              
            

            				super
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def format(node)
          
        
      
        

          

            
              14
            

            
              
            

            			@buffer.clear
          
        
      
        

          

            
              14
            

            
              
            

            			visit(node)
          
        
      
        

          

            
              14
            

            
              
            

            			[@buffer.join, @source_map]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_each(nodes)
          
        
      
        

          

            
              66
            

            
              
            

            			i, len = 0, nodes.length
          
        
      
        

          

            
              66
            

            
              
                
                  then: 66
                
              
            

            			if block_given?
          
        
      
        

          

            
              66
            

            
              
                
                  body: 137
                
              
            

            				while i < len
          
        
      
        

          

            
              137
            

            
              
            

            					node = nodes[i]
          
        
      
        

          

            
              137
            

            
              
            

            					i += 1
          
        
      
        

          

            
              137
            

            
              
                
                  then: 137
                
              
                
                  else: 0
                
              
            

            					if node
          
        
      
        

          

            
              137
            

            
              
            

            						visit node
          
        
      
        

          

            
              137
            

            
              
                
                  else: 66
                
              
                
                  then: 71
                
              
            

            						yield unless i == len
          
        
      
        

          

            

            
              
            

            					end
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            			else
          
        
      
        

          

            

            
              
                
                  body: 0
                
              
            

            				while i < len
          
        
      
        

          

            

            
              
            

            					visit nodes[i]
          
        
      
        

          

            

            
              
            

            					i += 1
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def statement
          
        
      
        

          

            

            
              
            

            			new_line
          
        
      
        

          

            

            
              
            

            			yield
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def parens
          
        
      
        

          

            
              2
            

            
              
            

            			push "("
          
        
      
        

          

            
              2
            

            
              
            

            			yield
          
        
      
        

          

            
              2
            

            
              
            

            			push ")"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def new_line
          
        
      
        

          

            
              247
            

            
              
            

            			push "\n"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def space
          
        
      
        

          

            
              80
            

            
              
            

            			push " "
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_node(node)
          
        
      
        

          

            
              30
            

            
              
            

            			emit node.opening_loc
          
        
      
        

          

            
              30
            

            
              
            

            			new_line
          
        
      
        

          

            
              30
            

            
              
            

            			visit node.body
          
        
      
        

          

            
              30
            

            
              
            

            			new_line
          
        
      
        

          

            
              30
            

            
              
            

            			emit node.closing_loc
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_node(node)
          
        
      
        

          

            
              35
            

            
              
            

            			visit node.receiver
          
        
      
        

          

            
              35
            

            
              
            

            			emit node.call_operator_loc
          
        
      
        

          

            
              35
            

            
              
            

            			emit node.message_loc
          
        
      
        

          

            
              35
            

            
              
                
                  then: 4
                
              
            

            			if node.opening_loc
          
        
      
        

          

            
              4
            

            
              
            

            				emit node.opening_loc
          
        
      
        

          

            

            
              
                
                  else: 31
                
              
            

            			else
          
        
      
        

          

            
              31
            

            
              
            

            				space
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            
              35
            

            
              
            

            			visit node.arguments
          
        
      
        

          

            
              35
            

            
              
            

            			emit node.closing_loc
          
        
      
        

          

            
              35
            

            
              
            

            			space
          
        
      
        

          

            
              35
            

            
              
            

            			visit node.block
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_def_node(node)
          
        
      
        

          

            
              14
            

            
              
            

            			push "def"
          
        
      
        

          

            
              14
            

            
              
            

            			space
          
        
      
        

          

            
              14
            

            
              
            

            			push node.name
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
                
                  then: 2
                
              
                
                  else: 12
                
              
            

            			if node.parameters
          
        
      
        

          

            
              2
            

            
              
            

            				parens do
          
        
      
        

          

            
              2
            

            
              
            

            					visit node.parameters
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
            

            			new_line
          
        
      
        

          

            
              14
            

            
              
            

            			visit node.body
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
            

            			new_line
          
        
      
        

          

            
              14
            

            
              
            

            			push "end"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_statements_node(node)
          
        
      
        

          

            
              137
            

            
              
            

            			visit_each(node.compact_child_nodes) { new_line }
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_string_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			push '"'
          
        
      
        

          

            
              1
            

            
              
            

            			node.parts.each do |part|
          
        
      
        

          

            
              5
            

            
              
                
                  else: 0
                
              
            

            				case part
          
        
      
        

          

            

            
              
                
                  when: 4
                
              
            

            				when Prism::StringNode
          
        
      
        

          

            
              4
            

            
              
            

            					push part.unescaped.gsub('"', '\"')
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

            				when Prism::EmbeddedStatementsNode
          
        
      
        

          

            
              1
            

            
              
            

            					visit(part)
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            
              1
            

            
              
            

            			push '"'
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            require "prism"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Compiler
          
        
      
        

          

            
              1
            

            
              
            

            	class MethodCompiler < Prism::MutationCompiler
          
        
      
        

          

            
              1
            

            
              
            

            		def initialize(component)
          
        
      
        

          

            
              14
            

            
              
            

            			@component = component
          
        
      
        

          

            
              14
            

            
              
            

            			@current_buffer = nil
          
        
      
        

          

            
              14
            

            
              
            

            			@preamble = Set[]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile(node)
          
        
      
        

          

            
              14
            

            
              
            

            			result = visit(node)
          
        
      
        

          

            
              14
            

            
              
                
                  then: 14
                
              
                
                  else: 0
                
              
                
                  then: 14
                
              
                
                  else: 0
                
              
            

            			result.body&.body&.unshift(@preamble, statement("nil"))
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              14
            

            
              
            

            			source, map = Phlex::Compiler::Formatter.new.format(result)
          
        
      
        

          

            
              14
            

            
              
            

            			source
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_node(node)
          
        
      
        

          

            
              63
            

            
              
                
                  then: 62
                
              
                
                  else: 1
                
              
            

            			if nil == node.receiver
          
        
      
        

          

            
              62
            

            
              
                
                  then: 41
                
              
            

            				if (tag = standard_element?(node))
          
        
      
        

          

            
              41
            

            
              
                
                  else: 21
                
              
            

            					return compile_standard_element(node, tag)
          
        
      
        

          

            
              21
            

            
              
                
                  then: 6
                
              
            

            				elsif (tag = void_element?(node))
          
        
      
        

          

            
              6
            

            
              
                
                  else: 15
                
              
            

            					return compile_void_element(node, tag)
          
        
      
        

          

            
              15
            

            
              
                
                  then: 2
                
              
            

            				elsif whitespace_helper?(node)
          
        
      
        

          

            
              2
            

            
              
                
                  else: 13
                
              
            

            					return compile_whitespace_helper(node)
          
        
      
        

          

            
              13
            

            
              
                
                  then: 0
                
              
            

            				elsif doctype_helper?(node)
          
        
      
        

          

            

            
              
                
                  else: 13
                
              
            

            					return compile_doctype_helper(node)
          
        
      
        

          

            
              13
            

            
              
                
                  then: 6
                
              
            

            				elsif plain_helper?(node)
          
        
      
        

          

            
              6
            

            
              
                
                  else: 7
                
              
            

            					return compile_plain_helper(node)
          
        
      
        

          

            
              7
            

            
              
                
                  then: 0
                
              
            

            				elsif fragment_helper?(node)
          
        
      
        

          

            

            
              
                
                  else: 7
                
              
            

            					return compile_fragment_helper(node)
          
        
      
        

          

            
              7
            

            
              
                
                  then: 2
                
              
            

            				elsif comment_helper?(node)
          
        
      
        

          

            
              2
            

            
              
                
                  else: 5
                
              
            

            					return compile_comment_helper(node)
          
        
      
        

          

            
              5
            

            
              
                
                  then: 1
                
              
                
                  else: 4
                
              
            

            				elsif raw_helper?(node)
          
        
      
        

          

            
              1
            

            
              
            

            					return compile_raw_helper(node)
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              5
            

            
              
            

            			clear_buffer
          
        
      
        

          

            
              5
            

            
              
            

            			super
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_node(node)
          
        
      
        

          

            

            
              
            

            			node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_module_node(node)
          
        
      
        

          

            

            
              
            

            			node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_standard_element(node, tag)
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              41
            

            
              
            

            					buffer("<#{tag}"),
          
        
      
        

          

            

            
              
            

            					*(
          
        
      
        

          

            
              41
            

            
              
                
                  then: 16
                
              
                
                  else: 25
                
              
            

            						if node.arguments
          
        
      
        

          

            
              16
            

            
              
            

            							visit_phlex_attributes(node.arguments)
          
        
      
        

          

            

            
              
            

            						end
          
        
      
        

          

            

            
              
            

            					),
          
        
      
        

          

            

            
              
            

            					buffer(">"),
          
        
      
        

          

            

            
              
            

            					*(
          
        
      
        

          

            
              41
            

            
              
                
                  then: 39
                
              
                
                  else: 2
                
              
            

            						if node.block
          
        
      
        

          

            
              39
            

            
              
            

            							[visit_phlex_block(node.block)]
          
        
      
        

          

            

            
              
            

            						end
          
        
      
        

          

            

            
              
            

            					),
          
        
      
        

          

            

            
              
            

            					buffer("</#{tag}>"),
          
        
      
        

          

            

            
              
            

            				],
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_phlex_attributes(node)
          
        
      
        

          

            
              19
            

            
              
                
                  then: 19
                
              
                
                  else: 0
                
              
            

            			if node.arguments in [Prism::KeywordHashNode[elements: attributes]]
          
        
      
        

          

            
              19
            

            
              
            

            				literal_attributes = attributes.all? do |attribute|
          
        
      
        

          

            
              38
            

            
              
            

            					Prism::AssocNode === attribute && static_attribute_value_literal?(attribute)
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              19
            

            
              
                
                  then: 19
                
              
                
                  else: 0
                
              
            

            				if literal_attributes
          
        
      
        

          

            
              19
            

            
              
            

            					return buffer(Phlex::SGML::Attributes.generate_attributes(eval("{#{node.slice}}")))
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            

            
              
            

            				:new_line,
          
        
      
        

          

            

            
              
            

            				push("__render_attributes__("),
          
        
      
        

          

            

            
              
            

            				node,
          
        
      
        

          

            

            
              
            

            				push(")"),
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_phlex_block(node)
          
        
      
        

          

            
              42
            

            
              
                
                  then: 1
                
              
            

            			if Prism::BlockArgumentNode === node
          
        
      
        

          

            
              1
            

            
              
                
                  else: 41
                
              
            

            				[push("__yield_content__("), node, push(")")]
          
        
      
        

          

            
              41
            

            
              
                
                  then: 17
                
              
            

            			elsif output_block?(node)
          
        
      
        

          

            
              17
            

            
              
                
                  else: 24
                
              
            

            				visit(node.body)
          
        
      
        

          

            
              24
            

            
              
                
                  then: 22
                
              
            

            			elsif content_block?(node)
          
        
      
        

          

            
              22
            

            
              
            

            				content = node.body.body.first
          
        
      
        

          

            
              22
            

            
              
            

            				case content
          
        
      
        

          

            

            
              
                
                  when: 17
                
              
            

            				when Prism::StringNode
          
        
      
        

          

            
              17
            

            
              
            

            					buffer(Phlex::Escape.html_escape(content.unescaped))
          
        
      
        

          

            

            
              
                
                  when: 5
                
              
            

            				when Prism::InterpolatedStringNode
          
        
      
        

          

            
              5
            

            
              
            

            					compile_interpolated_string_node(content)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            				else
          
        
      
        

          

            

            
              
            

            					raise
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 2
                
              
            

            			else
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              2
            

            
              
            

            					statement("__yield_content__ do"),
          
        
      
        

          

            

            
              
            

            					[node.body],
          
        
      
        

          

            

            
              
            

            					statement("end"),
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_node(node)
          
        
      
        

          

            
              3
            

            
              
            

            			node.copy(
          
        
      
        

          

            

            
              
            

            				body: compile_block_body_node(node.body)
          
        
      
        

          

            

            
              
            

            			)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_block_body_node(node)
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            
              3
            

            
              
            

            				statement("if #{self_local} == self"),
          
        
      
        

          

            

            
              
            

            				visit(node),
          
        
      
        

          

            

            
              
            

            				statement("else"),
          
        
      
        

          

            

            
              
            

            				[[node]],
          
        
      
        

          

            

            
              
            

            				statement("end"),
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_interpolated_string_node(node)
          
        
      
        

          

            
              5
            

            
              
            

            			node.parts.map do |part|
          
        
      
        

          

            
              15
            

            
              
            

            				case part
          
        
      
        

          

            

            
              
                
                  when: 10
                
              
            

            				when Prism::StringNode
          
        
      
        

          

            
              10
            

            
              
            

            					buffer(Phlex::Escape.html_escape(part.unescaped))
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

            				when Prism::EmbeddedVariableNode
          
        
      
        

          

            

            
              
            

            					[
          
        
      
        

          

            
              1
            

            
              
            

            						buffer('#{'),
          
        
      
        

          

            

            
              
            

            						buffer("::Phlex::Escape.html_escape(("),
          
        
      
        

          

            

            
              
            

            						buffer(part.variable.slice),
          
        
      
        

          

            

            
              
            

            						buffer(").to_s)}"),
          
        
      
        

          

            

            
              
            

            					]
          
        
      
        

          

            

            
              
                
                  when: 4
                
              
            

            				when Prism::EmbeddedStatementsNode
          
        
      
        

          

            

            
              
            

            					[
          
        
      
        

          

            
              4
            

            
              
            

            						buffer('#{'),
          
        
      
        

          

            

            
              
            

            						buffer("::Phlex::Escape.html_escape(("),
          
        
      
        

          

            

            
              
            

            						buffer(part.statements.slice, escape: false),
          
        
      
        

          

            

            
              
            

            						buffer(").to_s)}"),
          
        
      
        

          

            

            
              
            

            					]
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            				else
          
        
      
        

          

            

            
              
            

            					raise Phlex::Compiler::Error, "Unexpected node type in InterpolatedStringNode: #{part.class}"
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_void_element(node, tag)
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              6
            

            
              
            

            					buffer("<#{tag}"),
          
        
      
        

          

            

            
              
            

            					*(
          
        
      
        

          

            
              6
            

            
              
                
                  then: 3
                
              
                
                  else: 3
                
              
            

            						if node.arguments
          
        
      
        

          

            
              3
            

            
              
            

            							visit_phlex_attributes(node.arguments)
          
        
      
        

          

            

            
              
            

            						end
          
        
      
        

          

            

            
              
            

            					),
          
        
      
        

          

            

            
              
            

            					buffer(">"),
          
        
      
        

          

            

            
              
            

            				],
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_whitespace_helper(node)
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
            

            			if node.block
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              1
            

            
              
            

            					buffer(" "),
          
        
      
        

          

            

            
              
            

            					visit_phlex_block(node.block),
          
        
      
        

          

            

            
              
            

            					buffer(" "),
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            			else
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              1
            

            
              
            

            					buffer(" "),
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_doctype_helper(node)
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            

            
              
            

            				buffer("<!doctype html>"),
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_plain_helper(node)
          
        
      
        

          

            
              6
            

            
              
                
                  then: 5
                
              
            

            			if node.arguments in [Prism::StringNode]
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              5
            

            
              
            

            					buffer(node.arguments.child_nodes.first.unescaped),
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            			else
          
        
      
        

          

            
              1
            

            
              
            

            				@current_buffer = nil
          
        
      
        

          

            
              1
            

            
              
            

            				node
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_fragment_helper(node)
          
        
      
        

          

            

            
              
            

            			node.copy(
          
        
      
        

          

            

            
              
            

            				block: compile_fragment_helper_block(node.block)
          
        
      
        

          

            

            
              
            

            			)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_fragment_helper_block(node)
          
        
      
        

          

            

            
              
            

            			node.copy(
          
        
      
        

          

            

            
              
            

            				body: [
          
        
      
        

          

            

            
              
            

            					statement("__phlex_original_should_render__ = #{should_render_local}"),
          
        
      
        

          

            

            
              
            

            					statement("#{should_render_local} = #{state_local}.should_render?"),
          
        
      
        

          

            

            
              
            

            					visit(node.body),
          
        
      
        

          

            

            
              
            

            					statement("#{should_render_local} = __phlex_original_should_render__"),
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
            

            			)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_comment_helper(node)
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            
              2
            

            
              
            

            				buffer("<!-- "),
          
        
      
        

          

            

            
              
            

            				visit_phlex_block(node.block),
          
        
      
        

          

            

            
              
            

            				buffer(" -->"),
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def compile_raw_helper(node)
          
        
      
        

          

            
              1
            

            
              
            

            			clear_buffer
          
        
      
        

          

            
              1
            

            
              
            

            			node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def statement(string)
          
        
      
        

          

            
              27
            

            
              
            

            			clear_buffer
          
        
      
        

          

            

            
              
            

            			[
          
        
      
        

          

            
              27
            

            
              
            

            				:new_line,
          
        
      
        

          

            

            
              
            

            				string,
          
        
      
        

          

            

            
              
            

            				";",
          
        
      
        

          

            

            
              
            

            			]
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def push(value)
          
        
      
        

          

            
              2
            

            
              
            

            			clear_buffer
          
        
      
        

          

            
              2
            

            
              
            

            			value
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def clear_buffer
          
        
      
        

          

            
              35
            

            
              
            

            			@current_buffer = nil
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def buffer(value, escape: true)
          
        
      
        

          

            
              213
            

            
              
                
                  then: 193
                
              
            

            			if @current_buffer
          
        
      
        

          

            
              193
            

            
              
                
                  then: 189
                
              
            

            				if escape
          
        
      
        

          

            
              189
            

            
              
            

            					@current_buffer << value.gsub('"', '\\"')
          
        
      
        

          

            

            
              
                
                  else: 4
                
              
            

            				else
          
        
      
        

          

            
              4
            

            
              
            

            					@current_buffer << value
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            
              193
            

            
              
            

            				nil
          
        
      
        

          

            

            
              
                
                  else: 20
                
              
            

            			else
          
        
      
        

          

            
              20
            

            
              
            

            				new_buffer = +""
          
        
      
        

          

            
              20
            

            
              
            

            				@current_buffer = new_buffer
          
        
      
        

          

            
              20
            

            
              
                
                  then: 20
                
              
            

            				if escape
          
        
      
        

          

            
              20
            

            
              
            

            					new_buffer << value.gsub('"', '\\"')
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            				else
          
        
      
        

          

            

            
              
            

            					new_buffer << value
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				[
          
        
      
        

          

            
              20
            

            
              
            

            					:new_line,
          
        
      
        

          

            

            
              
            

            					"#{buffer_local} << \"",
          
        
      
        

          

            

            
              
            

            					new_buffer,
          
        
      
        

          

            

            
              
            

            					"\" if #{should_render_local}; nil;",
          
        
      
        

          

            

            
              
            

            				]
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def new_scope
          
        
      
        

          

            

            
              
            

            			original_in_scope = @in_scope
          
        
      
        

          

            

            
              
            

            			@in_scope = false
          
        
      
        

          

            

            
              
            

            			yield
          
        
      
        

          

            

            
              
            

            			@in_scope = original_in_scope
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def output_block?(node)
          
        
      
        

          

            
              41
            

            
              
            

            			node.body.body.any? do |child|
          
        
      
        

          

            
              41
            

            
              
            

            				Prism::CallNode === child && (standard_element?(child) || void_element?(child) || plain_helper?(child) || whitespace_helper?(child) || raw_helper?(child))
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def content_block?(node)
          
        
      
        

          

            
              24
            

            
              
                
                  else: 24
                
              
                
                  then: 0
                
              
            

            			return false unless node.body.body.length == 1
          
        
      
        

          

            
              24
            

            
              
            

            			node.body.body.first in Prism::StringNode | Prism::InterpolatedStringNode
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def standard_element?(node)
          
        
      
        

          

            
              80
            

            
              
            

            			if (tag = Phlex::HTML::StandardElements.__registered_elements__[node.name]) &&
          
        
      
        

          

            
              57
            

            
              
            

            					(Phlex::HTML::StandardElements == @component.instance_method(node.name).owner)
          
        
      
        

          

            

            
              
                
                  then: 57
                
              
            

            
          
        
      
        

          

            
              57
            

            
              
            

            				tag
          
        
      
        

          

            

            
              
                
                  else: 23
                
              
            

            			else
          
        
      
        

          

            
              23
            

            
              
            

            				false
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def void_element?(node)
          
        
      
        

          

            
              23
            

            
              
            

            			if (tag = Phlex::HTML::VoidElements.__registered_elements__[node.name]) &&
          
        
      
        

          

            
              9
            

            
              
            

            					(Phlex::HTML::VoidElements == @component.instance_method(node.name).owner)
          
        
      
        

          

            

            
              
                
                  then: 6
                
              
            

            
          
        
      
        

          

            
              6
            

            
              
            

            				tag
          
        
      
        

          

            

            
              
                
                  else: 17
                
              
            

            			else
          
        
      
        

          

            
              17
            

            
              
            

            				false
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def static_attribute_value_literal?(value)
          
        
      
        

          

            
              80
            

            
              
            

            			case value
          
        
      
        

          

            

            
              
                
                  when: 37
                
              
            

            			when Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode, Prism::FloatNode, Prism::TrueNode, Prism::FalseNode, Prism::NilNode
          
        
      
        

          

            
              37
            

            
              
            

            				true
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

            			when Prism::ArrayNode
          
        
      
        

          

            
              7
            

            
              
            

            				value.elements.all? { |n| static_token_value_literal?(n) }
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

            			when Prism::HashNode
          
        
      
        

          

            
              3
            

            
              
            

            				value.elements.all? { |n| static_attribute_value_literal?(n) }
          
        
      
        

          

            

            
              
                
                  when: 40
                
              
            

            			when Prism::AssocNode
          
        
      
        

          

            
              40
            

            
              
            

            				(Prism::StringNode === value.key || Prism::SymbolNode === value.key) && static_attribute_value_literal?(value.value)
          
        
      
        

          

            

            
              
                
                  when: 1
                
              
            

            			when Prism::CallNode
          
        
      
        

          

            
              1
            

            
              
                
                  then: 1
                
              
            

            				if value in { receiver: Prism::ConstantReadNode[name: :Set]| Prism::ConstantPathNode[name: :Set, parent: nil], name: :[] }
          
        
      
        

          

            
              7
            

            
              
            

            					value.arguments.arguments.all? { |n| static_token_value_literal?(n) }
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            				else
          
        
      
        

          

            

            
              
            

            					false
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            			else
          
        
      
        

          

            

            
              
            

            				false
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def static_token_value_literal?(value)
          
        
      
        

          

            
              14
            

            
              
            

            			case value
          
        
      
        

          

            

            
              
                
                  when: 12
                
              
            

            			when Prism::SymbolNode, Prism::StringNode, Prism::IntegerNode, Prism::FloatNode, Prism::NilNode
          
        
      
        

          

            
              12
            

            
              
            

            				true
          
        
      
        

          

            

            
              
                
                  when: 2
                
              
            

            			when Prism::ArrayNode
          
        
      
        

          

            
              4
            

            
              
            

            				value.elements.all? { |n| static_token_value_literal?(n) }
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            			else
          
        
      
        

          

            

            
              
            

            				false
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def whitespace_helper?(node)
          
        
      
        

          

            
              16
            

            
              
            

            			node.name == :whitespace && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def doctype_helper?(node)
          
        
      
        

          

            
              13
            

            
              
            

            			node.name == :doctype && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def plain_helper?(node)
          
        
      
        

          

            
              15
            

            
              
            

            			node.name == :plain && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def fragment_helper?(node)
          
        
      
        

          

            
              7
            

            
              
            

            			node.name == :fragment && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def comment_helper?(node)
          
        
      
        

          

            
              7
            

            
              
            

            			node.name == :comment && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def raw_helper?(node)
          
        
      
        

          

            
              6
            

            
              
            

            			node.name == :raw && own_method_without_scope?(node)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		ALLOWED_OWNERS = [Phlex::SGML, Phlex::HTML, Phlex::SVG]
          
        
      
        

          

            
              1
            

            
              
            

            		private def own_method_without_scope?(node)
          
        
      
        

          

            
              12
            

            
              
            

            			ALLOWED_OWNERS.include?(@component.instance_method(node.name).owner)
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def extract_kwargs_from_string(string)
          
        
      
        

          

            

            
              
            

            			eval("{#{string}}")
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def state_local
          
        
      
        

          

            
              40
            

            
              
            

            			@preamble << [:new_line, "__phlex_state__ = @_state;"]
          
        
      
        

          

            
              40
            

            
              
            

            			"__phlex_state__"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def buffer_local
          
        
      
        

          

            
              20
            

            
              
            

            			@preamble << [:new_line, "__phlex_buffer__ = #{state_local}.buffer;"]
          
        
      
        

          

            
              20
            

            
              
            

            			"__phlex_buffer__"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def self_local
          
        
      
        

          

            
              3
            

            
              
            

            			@preamble << [:new_line, "__phlex_self__ = self;"]
          
        
      
        

          

            
              3
            

            
              
            

            			"__phlex_self__"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		private def should_render_local
          
        
      
        

          

            
              20
            

            
              
            

            			@preamble << [:new_line, "__phlex_should_render__ = #{state_local}.should_render?;"]
          
        
      
        

          

            
              20
            

            
              
            

            			"__phlex_should_render__"
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Compiler
          
        
      
        

          

            
              1
            

            
              
            

            	class VerbatimFormatter < Prism::BasicVisitor
          
        
      
        

          

            
              1
            

            
              
            

            		def initialize
          
        
      
        

          

            
              14
            

            
              
            

            			@buffer = []
          
        
      
        

          

            
              14
            

            
              
            

            			@source_map = []
          
        
      
        

          

            
              14
            

            
              
            

            			@current_line = 1
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def push(value)
          
        
      
        

          

            
              681
            

            
              
                
                  else: 0
                
              
            

            			string = case value
          
        
      
        

          

            

            
              
                
                  when: 667
                
              
            

            			when String
          
        
      
        

          

            
              667
            

            
              
            

            				value
          
        
      
        

          

            

            
              
                
                  when: 14
                
              
            

            			when Symbol
          
        
      
        

          

            
              14
            

            
              
            

            				value.name
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              681
            

            
              
            

            			@buffer << string
          
        
      
        

          

            
              681
            

            
              
            

            			new_lines = string.count("\n")
          
        
      
        

          

            
              681
            

            
              
            

            			@current_line += new_lines
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def emit(node)
          
        
      
        

          

            
              209
            

            
              
                
                  else: 145
                
              
                
                  then: 64
                
              
            

            			return unless node
          
        
      
        

          

            
              145
            

            
              
            

            			source_map = @source_map
          
        
      
        

          

            
              145
            

            
              
            

            			current_line = @current_line
          
        
      
        

          

            
              145
            

            
              
            

            			start_line = node.start_line
          
        
      
        

          

            
              145
            

            
              
            

            			end_line = node.end_line
          
        
      
        

          

            
              145
            

            
              
            

            			number_of_lines = end_line - start_line
          
        
      
        

          

            
              145
            

            
              
            

            			i = 0
          
        
      
        

          

            
              145
            

            
              
                
                  body: 145
                
              
            

            			while i <= number_of_lines
          
        
      
        

          

            
              145
            

            
              
            

            				source_map[current_line + i] = start_line + i
          
        
      
        

          

            
              145
            

            
              
            

            				i += 1
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              145
            

            
              
            

            			push node.slice
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_alias_global_variable_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_alias_method_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_alternation_pattern_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_and_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_arguments_node(node)
          
        
      
        

          

            
              17
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_array_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_array_pattern_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_assoc_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_assoc_splat_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_back_reference_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_begin_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_argument_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_local_variable_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_block_parameters_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_break_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_call_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_capture_pattern_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_case_match_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_case_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_class_variable_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_path_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_constant_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_def_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_defined_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_else_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_embedded_statements_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_embedded_variable_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_ensure_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_false_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_find_pattern_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_flip_flop_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_float_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_for_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_forwarding_arguments_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_forwarding_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_forwarding_super_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_global_variable_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_hash_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_hash_pattern_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_if_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_imaginary_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_implicit_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_implicit_rest_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_in_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_index_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_index_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_index_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_index_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_read_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_instance_variable_write_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_integer_node(node)
          
        
      
        

          

            
              2
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_match_last_line_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_regular_expression_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_string_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_symbol_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_interpolated_x_string_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_it_local_variable_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_it_parameters_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_keyword_hash_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_keyword_rest_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_lambda_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_and_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_operator_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_or_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_local_variable_write_node(node)
          
        
      
        

          

            
              3
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_match_last_line_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_match_predicate_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_match_required_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_match_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_missing_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_module_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_multi_target_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_multi_write_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_next_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_nil_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_no_keywords_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_numbered_parameters_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_numbered_reference_read_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_optional_keyword_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_optional_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_or_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_parameters_node(node)
          
        
      
        

          

            
              2
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_parentheses_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_pinned_expression_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_pinned_variable_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_post_execution_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_pre_execution_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_program_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_range_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_rational_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_redo_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_regular_expression_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_required_keyword_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_required_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_rescue_modifier_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_rescue_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_rest_parameter_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_retry_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_return_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_self_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_shareable_constant_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_singleton_class_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_source_encoding_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_source_file_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_source_line_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_splat_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_statements_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_string_node(node)
          
        
      
        

          

            
              11
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_super_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_symbol_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_true_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_undef_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_unless_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_until_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_when_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_while_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_x_string_node(node)
          
        
      
        

          

            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		def visit_yield_node(node)
          
        
      
        

          

            
              1
            

            
              
            

            			emit node
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::CSV
          
        
      
        

          

            
              1
            

            
              
            

            	FORMULA_PREFIXES_MAP = Array.new(128).tap do |map|
          
        
      
        

          

            
              1
            

            
              
            

            		"=+-@\t\r".each_byte do |byte|
          
        
      
        

          

            
              6
            

            
              
            

            			map[byte] = true
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end.freeze
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	UNDEFINED = Object.new
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def initialize(collection)
          
        
      
        

          

            
              14
            

            
              
            

            		@collection = collection
          
        
      
        

          

            
              14
            

            
              
            

            		@_row_buffer = []
          
        
      
        

          

            
              14
            

            
              
            

            		@_headers = []
          
        
      
        

          

            
              14
            

            
              
            

            		@_row_appender = nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	attr_reader :collection
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def call(buffer = +"", context: nil, delimiter: self.delimiter)
          
        
      
        

          

            
              12
            

            
              
            

            		ensure_escape_csv_injection_configured!
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
            

            		strip_whitespace = trim_whitespace?
          
        
      
        

          

            
              11
            

            
              
            

            		escape_csv_injection = escape_csv_injection?
          
        
      
        

          

            
              11
            

            
              
            

            		row_buffer = @_row_buffer
          
        
      
        

          

            
              11
            

            
              
            

            		headers = @_headers
          
        
      
        

          

            
              11
            

            
              
            

            		has_yielder = respond_to?(:yielder, true)
          
        
      
        

          

            
              11
            

            
              
            

            		first_row = true
          
        
      
        

          

            
              11
            

            
              
            

            		render_headers = render_headers?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              11
            

            
              
                
                  then: 1
                
              
                
                  else: 10
                
              
            

            		if delimiter.length != 1
          
        
      
        

          

            
              1
            

            
              
            

            			raise Phlex::ArgumentError.new("Delimiter must be a single character")
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 4
                
              
            

            		if strip_whitespace
          
        
      
        

          

            
              4
            

            
              
            

            			escape_regex = /[\n"#{delimiter}]/
          
        
      
        

          

            

            
              
                
                  else: 6
                
              
            

            		else
          
        
      
        

          

            
              6
            

            
              
            

            			escape_regex = /^\s|\s$|[\n"#{delimiter}]/
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 1
                
              
                
                  else: 9
                
              
            

            		if has_yielder
          
        
      
        

          

            
              1
            

            
              
            

            			warn <<~MESSAGE
          
        
      
        

          

            

            
              
            

            				Custom yielders are deprecated in Phlex::CSV.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				Please replace your yielder with an `around_row` method.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				You should be able to just rename your yielder method
          
        
      
        

          

            

            
              
            

            				and change `yield` to `super`.
          
        
      
        

          

            

            
              
            

            			MESSAGE
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

            		row_appender = -> {
          
        
      
        

          

            
              84
            

            
              
            

            			row = row_buffer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              84
            

            
              
                
                  then: 10
                
              
                
                  else: 74
                
              
            

            			if first_row
          
        
      
        

          

            
              10
            

            
              
            

            				first_row = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

            				i = 0
          
        
      
        

          

            
              10
            

            
              
            

            				number_of_columns = row.length
          
        
      
        

          

            
              10
            

            
              
            

            				first_col = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  body: 20
                
              
            

            				while i < number_of_columns
          
        
      
        

          

            
              20
            

            
              
            

            					header, = row[i]
          
        
      
        

          

            
              20
            

            
              
            

            					headers[i] = header
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              20
            

            
              
                
                  then: 18
                
              
                
                  else: 2
                
              
            

            					if render_headers
          
        
      
        

          

            
              18
            

            
              
                
                  then: 9
                
              
            

            						if first_col
          
        
      
        

          

            
              9
            

            
              
            

            							first_col = false
          
        
      
        

          

            

            
              
                
                  else: 9
                
              
            

            						else
          
        
      
        

          

            
              9
            

            
              
            

            							buffer << delimiter
          
        
      
        

          

            

            
              
            

            						end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              18
            

            
              
            

            						__escape__(buffer, header, escape_csv_injection:, strip_whitespace:, escape_regex:)
          
        
      
        

          

            

            
              
            

            					end
          
        
      
        

          

            
              20
            

            
              
            

            					i += 1
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 9
                
              
                
                  else: 1
                
              
            

            				buffer << "\n" if render_headers
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              84
            

            
              
            

            			i = 0
          
        
      
        

          

            
              84
            

            
              
            

            			number_of_columns = row.length
          
        
      
        

          

            
              84
            

            
              
            

            			first_col = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              84
            

            
              
                
                  body: 168
                
              
            

            			while i < number_of_columns
          
        
      
        

          

            
              168
            

            
              
            

            				header, value = row[i]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              168
            

            
              
                
                  else: 168
                
              
                
                  then: 0
                
              
            

            				unless headers[i] == header
          
        
      
        

          

            

            
              
            

            					raise Phlex::RuntimeError.new("Header mismatch at index #{i}: expected #{headers[i]}, got #{header}.")
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              168
            

            
              
                
                  then: 84
                
              
            

            				if first_col
          
        
      
        

          

            
              84
            

            
              
            

            					first_col = false
          
        
      
        

          

            

            
              
                
                  else: 84
                
              
            

            				else
          
        
      
        

          

            
              84
            

            
              
            

            					buffer << delimiter
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              168
            

            
              
            

            				__escape__(buffer, value, escape_csv_injection:, strip_whitespace:, escape_regex:)
          
        
      
        

          

            
              168
            

            
              
            

            				i += 1
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              84
            

            
              
            

            			buffer << "\n"
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              84
            

            
              
            

            			row_buffer.clear
          
        
      
        

          

            

            
              
            

            		}
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
                
                  then: 1
                
              
            

            		if has_yielder
          
        
      
        

          

            
              1
            

            
              
            

            			each_item do |record|
          
        
      
        

          

            
              7
            

            
              
            

            				yielder(record) do |*a, **k|
          
        
      
        

          

            
              14
            

            
              
            

            					row_template(*a, **k)
          
        
      
        

          

            
              14
            

            
              
            

            					row_appender.call
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
                
                  else: 9
                
              
            

            		else
          
        
      
        

          

            
              9
            

            
              
            

            			@row_appender = row_appender
          
        
      
        

          

            
              9
            

            
              
            

            			each_item do |record|
          
        
      
        

          

            
              63
            

            
              
            

            				around_row(record)
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              10
            

            
              
            

            		buffer
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def around_row(...)
          
        
      
        

          

            
              70
            

            
              
            

            		row_template(...)
          
        
      
        

          

            
              70
            

            
              
            

            		@row_appender.call
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def filename
          
        
      
        

          

            
              1
            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def content_type
          
        
      
        

          

            
              1
            

            
              
            

            		"text/csv"
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def delimiter
          
        
      
        

          

            
              9
            

            
              
            

            		","
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def column(header = nil, value)
          
        
      
        

          

            
              168
            

            
              
            

            		@_row_buffer << [header, value]
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def each_item(&)
          
        
      
        

          

            
              10
            

            
              
            

            		collection.each(&)
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Override and set to `false` to disable rendering headers.
          
        
      
        

          

            
              1
            

            
              
            

            	private def render_headers?
          
        
      
        

          

            
              10
            

            
              
            

            		true
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Override and set to `true` to strip leading and trailing whitespace from values.
          
        
      
        

          

            
              1
            

            
              
            

            	private def trim_whitespace?
          
        
      
        

          

            
              3
            

            
              
            

            		false
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Override and set to `false` to disable CSV injection escapes or `true` to enable.
          
        
      
        

          

            
              1
            

            
              
            

            	private def escape_csv_injection?
          
        
      
        

          

            
              1
            

            
              
            

            		UNDEFINED
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def __escape__(buffer, value, escape_csv_injection:, strip_whitespace:, escape_regex:)
          
        
      
        

          

            
              186
            

            
              
            

            		value = case value
          
        
      
        

          

            

            
              
                
                  when: 126
                
              
            

            		when String
          
        
      
        

          

            
              126
            

            
              
            

            			value
          
        
      
        

          

            

            
              
                
                  when: 12
                
              
            

            		when Symbol
          
        
      
        

          

            
              12
            

            
              
            

            			value.name
          
        
      
        

          

            

            
              
                
                  else: 48
                
              
            

            		else
          
        
      
        

          

            
              48
            

            
              
            

            			value.to_s
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              186
            

            
              
                
                  then: 64
                
              
            

            		if strip_whitespace
          
        
      
        

          

            
              64
            

            
              
            

            			value = value.strip
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              64
            

            
              
                
                  then: 48
                
              
            

            			if escape_csv_injection
          
        
      
        

          

            
              48
            

            
              
                
                  then: 12
                
              
            

            				if value.empty?
          
        
      
        

          

            
              12
            

            
              
                
                  else: 36
                
              
            

            					buffer << value
          
        
      
        

          

            
              36
            

            
              
                
                  then: 6
                
              
            

            				elsif FORMULA_PREFIXES_MAP[value.getbyte(0)]
          
        
      
        

          

            
              6
            

            
              
            

            					value.gsub!('"', '""')
          
        
      
        

          

            
              6
            

            
              
                
                  else: 30
                
              
            

            					buffer << '"\'' << value << '"'
          
        
      
        

          

            
              30
            

            
              
                
                  then: 6
                
              
            

            				elsif value.match?(escape_regex)
          
        
      
        

          

            
              6
            

            
              
            

            					value.gsub!('"', '""')
          
        
      
        

          

            
              6
            

            
              
            

            					buffer << '"' << value << '"'
          
        
      
        

          

            

            
              
                
                  else: 24
                
              
            

            				else
          
        
      
        

          

            
              24
            

            
              
            

            					buffer << value
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 16
                
              
            

            			else # not escaping CSV injection
          
        
      
        

          

            
              16
            

            
              
            

            				buffer << value
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
                
                  else: 122
                
              
            

            		else # not stripping whitespace
          
        
      
        

          

            
              122
            

            
              
                
                  then: 92
                
              
            

            			if escape_csv_injection
          
        
      
        

          

            
              92
            

            
              
            

            				first_byte = value.getbyte(0)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              92
            

            
              
                
                  then: 24
                
              
            

            				if value.empty?
          
        
      
        

          

            
              24
            

            
              
                
                  else: 68
                
              
            

            					buffer << '""'
          
        
      
        

          

            
              68
            

            
              
                
                  then: 12
                
              
            

            				elsif FORMULA_PREFIXES_MAP[first_byte]
          
        
      
        

          

            
              12
            

            
              
                
                  else: 56
                
              
            

            					buffer << '"\'' << value.gsub('"', '""') << '"'
          
        
      
        

          

            
              56
            

            
              
                
                  then: 18
                
              
            

            				elsif value.match?(escape_regex)
          
        
      
        

          

            
              18
            

            
              
            

            					buffer << '"' << value.gsub('"', '""') << '"'
          
        
      
        

          

            

            
              
                
                  else: 38
                
              
            

            				else
          
        
      
        

          

            
              38
            

            
              
            

            					buffer << value
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 30
                
              
            

            			else # not escaping CSV injection
          
        
      
        

          

            
              30
            

            
              
                
                  then: 8
                
              
            

            				if value.empty?
          
        
      
        

          

            
              8
            

            
              
                
                  else: 22
                
              
            

            					buffer << '""'
          
        
      
        

          

            
              22
            

            
              
                
                  then: 6
                
              
            

            				elsif value.match?(escape_regex)
          
        
      
        

          

            
              6
            

            
              
            

            					buffer << '"' << value.gsub('"', '""') << '"'
          
        
      
        

          

            

            
              
                
                  else: 16
                
              
            

            				else
          
        
      
        

          

            
              16
            

            
              
            

            					buffer << value
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Handle legacy `view_template` method
          
        
      
        

          

            
              1
            

            
              
            

            	private def respond_to_missing?(method_name, include_private)
          
        
      
        

          

            
              10
            

            
              
            

            		(method_name == :row_template && respond_to?(:view_template)) || super
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Handle legacy `view_template` method
          
        
      
        

          

            
              1
            

            
              
            

            	private def method_missing(method_name, ...)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

            		if method_name == :row_template && respond_to?(:view_template)
          
        
      
        

          

            

            
              
            

            			warn "Deprecated: Use `row_template` instead of `view_template` in Phlex CSVs."
          
        
      
        

          

            

            
              
            

            			self.class.alias_method :row_template, :view_template
          
        
      
        

          

            

            
              
            

            			view_template(...)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            		else
          
        
      
        

          

            

            
              
            

            			super
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def ensure_escape_csv_injection_configured!
          
        
      
        

          

            
              12
            

            
              
                
                  then: 1
                
              
                
                  else: 11
                
              
            

            		if escape_csv_injection? == UNDEFINED
          
        
      
        

          

            
              1
            

            
              
            

            			raise <<~MESSAGE
          
        
      
        

          

            

            
              
            

            				You need to define `escape_csv_injection?` in #{self.class.name}.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				CSV injection is a security vulnerability where malicious spreadsheet
          
        
      
        

          

            

            
              
            

            				formulae are used to execute code or exfiltrate data when a CSV is opened
          
        
      
        

          

            

            
              
            

            				in a spreadsheet program such as Microsoft Excel or Google Sheets.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				For more information, see https://owasp.org/www-community/attacks/CSV_Injection
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				If you’re sure this CSV will never be opened in a spreadsheet program,
          
        
      
        

          

            

            
              
            

            				you can *disable* CSV injection escapes:
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				  def escape_csv_injection? = false
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				This is useful when using CSVs for byte-for-byte data exchange between secure systems.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				Alternatively, you can *enable* CSV injection escapes at the cost of data integrity:
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				  def escape_csv_injection? = true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				Enabling the CSV injection escapes will prefix with a single quote `'` any
          
        
      
        

          

            

            
              
            

            				values that start with: `=`, `+`, `-`, `@`, `\\t`, `\\r`
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				Unfortunately, there is no one-size-fits-all solution to CSV injection.
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            				You need to decide based on your specific use case.
          
        
      
        

          

            

            
              
            

            			MESSAGE
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # @api private
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Error
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::ArgumentError < ArgumentError
          
        
      
        

          

            
              1
            

            
              
            

            	include Phlex::Error
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::DoubleRenderError < RuntimeError
          
        
      
        

          

            
              1
            

            
              
            

            	include Phlex::Error
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::NameError < NameError
          
        
      
        

          

            
              1
            

            
              
            

            	include Phlex::Error
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::RuntimeError < RuntimeError
          
        
      
        

          

            
              1
            

            
              
            

            	include Phlex::Error
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # @api private
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::FIFO
          
        
      
        

          

            
              1
            

            
              
            

            	def initialize(max_bytesize: 2_000, max_value_bytesize: 2_000)
          
        
      
        

          

            
              15
            

            
              
            

            		@store = {}
          
        
      
        

          

            
              15
            

            
              
            

            		@max_bytesize = max_bytesize
          
        
      
        

          

            
              15
            

            
              
            

            		@max_value_bytesize = max_value_bytesize
          
        
      
        

          

            
              15
            

            
              
            

            		@bytesize = 0
          
        
      
        

          

            
              15
            

            
              
            

            		@mutex = Monitor.new
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	attr_reader :bytesize, :max_bytesize
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def expand(bytes)
          
        
      
        

          

            
              41
            

            
              
            

            		@mutex.synchronize do
          
        
      
        

          

            
              41
            

            
              
            

            			@max_bytesize += bytes
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def [](key)
          
        
      
        

          

            
              1806
            

            
              
            

            		k, v = @store[key.hash]
          
        
      
        

          

            
              1806
            

            
              
                
                  then: 1593
                
              
                
                  else: 213
                
              
            

            		v if k.eql?(key)
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def []=(key, value)
          
        
      
        

          

            
              287
            

            
              
                
                  then: 1
                
              
                
                  else: 286
                
              
            

            		return if value.bytesize > @max_value_bytesize
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              286
            

            
              
            

            		digest = key.hash
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              286
            

            
              
            

            		@mutex.synchronize do
          
        
      
        

          

            

            
              
            

            			# Check the key definitely doesn't exist now we have the lock
          
        
      
        

          

            
              286
            

            
              
                
                  then: 1
                
              
                
                  else: 285
                
              
            

            			return if @store[digest]
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              285
            

            
              
            

            			@store[digest] = [key, value].freeze
          
        
      
        

          

            
              285
            

            
              
            

            			@bytesize += value.bytesize
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              285
            

            
              
                
                  body: 97
                
              
            

            			while @bytesize > @max_bytesize
          
        
      
        

          

            
              97
            

            
              
            

            				k, v = @store.shift
          
        
      
        

          

            
              97
            

            
              
            

            				@bytesize -= v[1].bytesize
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def size
          
        
      
        

          

            
              2
            

            
              
            

            		@store.size
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def clear
          
        
      
        

          

            

            
              
            

            		@mutex.synchronize do
          
        
      
        

          

            

            
              
            

            			@store.clear
          
        
      
        

          

            

            
              
            

            			@bytesize = 0
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # An extremely fast in-memory cache store that evicts keys on a first-in-first-out basis.
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::FIFOCacheStore
          
        
      
        

          

            
              1
            

            
              
            

            	def initialize(max_bytesize: 2 ** 20)
          
        
      
        

          

            
              11
            

            
              
            

            		@fifo = Phlex::FIFO.new(
          
        
      
        

          

            

            
              
            

            			max_bytesize:,
          
        
      
        

          

            

            
              
            

            			max_value_bytesize: max_bytesize
          
        
      
        

          

            

            
              
            

            		)
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def fetch(key)
          
        
      
        

          

            
              29
            

            
              
            

            		fifo = @fifo
          
        
      
        

          

            
              29
            

            
              
            

            		key = map_key(key)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              29
            

            
              
                
                  then: 7
                
              
            

            		if (result = fifo[key])
          
        
      
        

          

            
              7
            

            
              
            

            			JSON.parse(result)
          
        
      
        

          

            

            
              
                
                  else: 22
                
              
            

            		else
          
        
      
        

          

            
              22
            

            
              
            

            			result = yield
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              22
            

            
              
            

            			fifo[key] = JSON.fast_generate(result)
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              22
            

            
              
            

            			result
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	def clear
          
        
      
        

          

            

            
              
            

            		@fifo.clear
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def map_key(value)
          
        
      
        

          

            
              192
            

            
              
            

            		case value
          
        
      
        

          

            

            
              
                
                  when: 50
                
              
            

            		when Array
          
        
      
        

          

            
              213
            

            
              
            

            			value.map { |it| map_key(it) }
          
        
      
        

          

            

            
              
                
                  when: 0
                
              
            

            		when Hash
          
        
      
        

          

            

            
              
            

            			value.to_h { |k, v| [map_key(k), map_key(v)].freeze }
          
        
      
        

          

            

            
              
                
                  when: 142
                
              
            

            		when String, Symbol, Integer, Float, Time, true, false, nil
          
        
      
        

          

            
              142
            

            
              
            

            			value
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            		else
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

            			if value.respond_to?(:cache_key_with_version)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            				map_key(value.cache_key_with_version)
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
            

            			elsif value.respond_to?(:cache_key)
          
        
      
        

          

            

            
              
            

            				map_key(value.cache_key)
          
        
      
        

          

            

            
              
                
                  else: 0
                
              
            

            			else
          
        
      
        

          

            

            
              
            

            				raise ArgumentError.new("Invalid cache key: #{value.class}")
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            # @api private
          
        
      
        

          

            
              1
            

            
              
            

            module Phlex::Helpers
          
        
      
        

          

            
              1
            

            
              
            

            	private def mix(*args)
          
        
      
        

          

            
              16
            

            
              
            

            		args.each_with_object({}) do |object, result|
          
        
      
        

          

            
              32
            

            
              
            

            			result.merge!(object) do |_key, old, new|
          
        
      
        

          

            
              15
            

            
              
            

            				case [old, new].freeze
          
        
      
        

          

            

            
              
                
                  in: 2
                
              
            

            				in [Array, Array] | [Set, Set]
          
        
      
        

          

            
              2
            

            
              
            

            					old + new
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [Array, Set]
          
        
      
        

          

            
              1
            

            
              
            

            					old + new.to_a
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [Array, String]
          
        
      
        

          

            
              1
            

            
              
            

            					old + [new]
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [Hash, Hash]
          
        
      
        

          

            
              1
            

            
              
            

            					mix(old, new)
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [Set, Array]
          
        
      
        

          

            
              1
            

            
              
            

            					old.to_a + new
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [Set, String]
          
        
      
        

          

            
              1
            

            
              
            

            					old.to_a + [new]
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [String, Array]
          
        
      
        

          

            
              1
            

            
              
            

            					[old] + new
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [String, Set]
          
        
      
        

          

            
              1
            

            
              
            

            					[old] + new.to_a
          
        
      
        

          

            

            
              
                
                  in: 2
                
              
            

            				in [String, String]
          
        
      
        

          

            
              2
            

            
              
            

            					"#{old} #{new}"
          
        
      
        

          

            

            
              
                
                  in: 1
                
              
            

            				in [_, Hash]
          
        
      
        

          

            
              1
            

            
              
            

            					{ _: old, **new }
          
        
      
        

          

            

            
              
                
                  in: 0
                
              
            

            				in [Hash, _]
          
        
      
        

          

            

            
              
            

            					{ **old, _: new }
          
        
      
        

          

            

            
              
                
                  in: 2
                
              
            

            				in [_, nil]
          
        
      
        

          

            
              2
            

            
              
            

            					old
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            				else
          
        
      
        

          

            
              1
            

            
              
            

            					new
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              32
            

            
              
            

            			result.transform_keys! do |key|
          
        
      
        

          

            
              33
            

            
              
                
                  then: 1
                
              
                
                  else: 32
                
              
            

            				key.end_with?("!") ? key.name.chop.to_sym : key
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            	private def grab(**bindings)
          
        
      
        

          

            
              2
            

            
              
                
                  then: 1
                
              
            

            		if bindings.size > 1
          
        
      
        

          

            
              1
            

            
              
            

            			bindings.values
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            		else
          
        
      
        

          

            
              1
            

            
              
            

            			bindings.values.first
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end
          
        
      
    
  

    

      
        

          

            

            
              
            

            # frozen_string_literal: true
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            class Phlex::HTML < Phlex::SGML
          
        
      
        

          

            
              1
            

            
              
            

            	extend Phlex::SGML::Elements
          
        
      
        

          

            
              1
            

            
              
            

            	include VoidElements, StandardElements
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Output an HTML doctype.
          
        
      
        

          

            
              1
            

            
              
            

            	def doctype
          
        
      
        

          

            
              5
            

            
              
            

            		state = @_state
          
        
      
        

          

            
              5
            

            
              
                
                  else: 1
                
              
                
                  then: 4
                
              
            

            		return unless state.should_render?
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              1
            

            
              
            

            		state.buffer << "<!doctype html>"
          
        
      
        

          

            
              1
            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Outputs an `<svg>` tag.
          
        
      
        

          

            

            
              
            

            	#
          
        
      
        

          

            

            
              
            

            	# [MDN Docs](https://developer.mozilla.org/docs/Web/SVG/Element/svg)
          
        
      
        

          

            

            
              
            

            	# [Spec](https://html.spec.whatwg.org/#the-svg-element)
          
        
      
        

          

            
              1
            

            
              
            

            	def svg(*, **, &)
          
        
      
        

          

            
              6
            

            
              
                
                  then: 5
                
              
            

            		if block_given?
          
        
      
        

          

            
              10
            

            
              
            

            			super { render Phlex::SVG.new(&) }
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            		else
          
        
      
        

          

            
              1
            

            
              
            

            			super
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Override to provide a filename for the HTML file
          
        
      
        

          

            
              1
            

            
              
            

            	def filename
          
        
      
        

          

            

            
              
            

            		nil
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Returns the string "text/html"
          
        
      
        

          

            
              1
            

            
              
            

            	def content_type
          
        
      
        

          

            
              1
            

            
              
            

            		"text/html"
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            

            
              
            

            	# Output an HTML tag dynamically, e.g:
          
        
      
        

          

            

            
              
            

            	#
          
        
      
        

          

            

            
              
            

            	# ```ruby
          
        
      
        

          

            

            
              
            

            	# @tag_name = :h1
          
        
      
        

          

            

            
              
            

            	# tag(@tag_name, class: "title")
          
        
      
        

          

            

            
              
            

            	# ```
          
        
      
        

          

            
              1
            

            
              
            

            	def tag(name, **attributes, &)
          
        
      
        

          

            
              452
            

            
              
            

            		state = @_state
          
        
      
        

          

            
              452
            

            
              
            

            		block_given = block_given?
          
        
      
        

          

            
              452
            

            
              
            

            		buffer = state.buffer
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              452
            

            
              
                
                  else: 452
                
              
                
                  then: 0
                
              
            

            		unless state.should_render?
          
        
      
        

          

            

            
              
                
                  then: 0
                
              
                
                  else: 0
                
              
            

            			yield(self) if block_given
          
        
      
        

          

            

            
              
            

            			return nil
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              452
            

            
              
                
                  else: 451
                
              
                
                  then: 1
                
              
            

            		unless Symbol === name
          
        
      
        

          

            
              1
            

            
              
            

            			raise Phlex::ArgumentError.new("Expected the tag name to be a Symbol.")
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              451
            

            
              
                
                  then: 414
                
              
            

            		if (tag = StandardElements.__registered_elements__[name]) || (tag = name.name.tr("_", "-")).include?("-")
          
        
      
        

          

            
              414
            

            
              
                
                  then: 206
                
              
            

            			if attributes.length > 0 # with attributes
          
        
      
        

          

            
              206
            

            
              
                
                  then: 103
                
              
            

            				if block_given # with content block
          
        
      
        

          

            
              103
            

            
              
            

            					buffer << "<#{tag}" << (Phlex::ATTRIBUTE_CACHE[attributes] ||= Phlex::SGML::Attributes.generate_attributes(attributes)) << ">"
          
        
      
        

          

            
              103
            

            
              
                
                  then: 1
                
              
            

            					if tag == "svg"
          
        
      
        

          

            
              1
            

            
              
            

            						render Phlex::SVG.new(&)
          
        
      
        

          

            

            
              
                
                  else: 102
                
              
            

            					else
          
        
      
        

          

            
              102
            

            
              
            

            						__yield_content__(&)
          
        
      
        

          

            

            
              
            

            					end
          
        
      
        

          

            
              103
            

            
              
            

            					buffer << "</#{tag}>"
          
        
      
        

          

            

            
              
                
                  else: 103
                
              
            

            				else # without content
          
        
      
        

          

            
              103
            

            
              
            

            					buffer << "<#{tag}" << (::Phlex::ATTRIBUTE_CACHE[attributes] ||= Phlex::SGML::Attributes.generate_attributes(attributes)) << "></#{tag}>"
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 208
                
              
            

            			else # without attributes
          
        
      
        

          

            
              208
            

            
              
                
                  then: 104
                
              
            

            				if block_given # with content block
          
        
      
        

          

            
              104
            

            
              
            

            					buffer << ("<#{tag}>")
          
        
      
        

          

            
              104
            

            
              
                
                  then: 2
                
              
            

            					if tag == "svg"
          
        
      
        

          

            
              2
            

            
              
            

            						render Phlex::SVG.new(&)
          
        
      
        

          

            

            
              
                
                  else: 102
                
              
            

            					else
          
        
      
        

          

            
              102
            

            
              
            

            						__yield_content__(&)
          
        
      
        

          

            

            
              
            

            					end
          
        
      
        

          

            
              104
            

            
              
            

            					buffer << "</#{tag}>"
          
        
      
        

          

            

            
              
                
                  else: 104
                
              
            

            				else # without content
          
        
      
        

          

            
              104
            

            
              
            

            					buffer << "<#{tag}></#{tag}>"
          
        
      
        

          

            

            
              
            

            				end
          
        
      
        

          

            

            
              
                
                  else: 37
                
              
            

            			end
          
        
      
        

          

            
              37
            

            
              
                
                  then: 36
                
              
            

            		elsif (tag = VoidElements.__registered_elements__[name])
          
        
      
        

          

            
              36
            

            
              
                
                  then: 12
                
              
                
                  else: 24
                
              
            

            			if block_given
          
        
      
        

          

            
              12
            

            
              
            

            				raise Phlex::ArgumentError.new("Void elements cannot have content blocks.")
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              24
            

            
              
                
                  then: 12
                
              
            

            			if attributes.length > 0 # with attributes
          
        
      
        

          

            
              12
            

            
              
            

            				buffer << "<#{tag}" << (::Phlex::ATTRIBUTE_CACHE[attributes] ||= Phlex::SGML::Attributes.generate_attributes(attributes)) << ">"
          
        
      
        

          

            

            
              
                
                  else: 12
                
              
            

            			else # without attributes
          
        
      
        

          

            
              12
            

            
              
            

            				buffer << "<#{tag}>"
          
        
      
        

          

            

            
              
            

            			end
          
        
      
        

          

            

            
              
            

            
          
        
      
        

          

            
              24
            

            
              
            

            			nil
          
        
      
        

          

            

            
              
                
                  else: 1
                
              
            

            		else
          
        
      
        

          

            
              1
            

            
              
            

            			raise Phlex::ArgumentError.new("Invalid HTML tag: #{name}")
          
        
      
        

          

            

            
              
            

            		end
          
        
      
        

          

            

            
              
            

            	end
          
        
      
        

          

            

            
              
            

            end