css_parser 0.9.0

data/lib/css_parser/rule_set.rb

@@ -0,0 +1,381 @@
+module CssParser
+  class RuleSet
+    # Patterns for specificity calculations
+    RE_ELEMENTS_AND_PSEUDO_ELEMENTS = /((^|[\s\+\>]+)[\w]+|\:(first\-line|first\-letter|before|after))/i
+    RE_NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES = /(\.[\w]+)|(\[[\w]+)|(\:(link|first\-child|lang))/i
+
+    # Array of selector strings.
+    attr_reader   :selectors
+    
+    # Integer with the specificity to use for this RuleSet.
+    attr_accessor   :specificity
+
+    def initialize(selectors, block, specificity = nil)
+      @selectors = []
+      @specificity = specificity
+      @declarations = {}
+      parse_selectors!(selectors) if selectors
+      parse_declarations!(block)
+    end
+
+
+    # Get the value of a property
+    def get_value(property)
+      return '' unless property and not property.empty?
+
+      property = property.downcase.strip
+      properties = @declarations.inject('') do |val, (key, data)|
+        #puts "COMPARING #{key} #{key.inspect} against #{property} #{property.inspect}"
+        importance = data[:is_important] ? ' !important' : ''
+        val << "#{data[:value]}#{importance}; " if key.downcase.strip == property
+        val
+      end
+      return properties ? properties.strip : ''
+    end
+    alias_method :[], :get_value
+
+    # Add a CSS declaration to the current RuleSet.
+    #
+    #  rule_set.add_declaration!('color', 'blue')
+    #
+    #  puts rule_set['color']
+    #  => 'blue;'
+    #
+    #  rule_set.add_declaration!('margin', '0px auto !important')
+    #
+    #  puts rule_set['margin']
+    #  => '0px auto !important;'
+    #
+    # If the property already exists its value will be over-written.
+    def add_declaration!(property, value)
+      value.gsub!(/;\Z/, '')
+      is_important = !value.gsub!(CssParser::IMPORTANT_IN_PROPERTY_RX, '').nil?
+      property = property.downcase.strip
+      #puts "SAVING #{property}  #{value} #{is_important.inspect}"
+      @declarations[property] = {:value => value, :is_important => is_important}
+    end
+    alias_method :[]=, :add_declaration!
+
+    # Iterate through selectors.
+    #
+    # Options
+    # -  +force_important+ -- boolean
+    #
+    # ==== Example
+    #   ruleset.each_selector do |sel, dec, spec|
+    #     ...
+    #   end
+    def each_selector(options = {}) # :yields: selector, declarations, specificity
+      declarations = declarations_to_s(options)
+      if @specificity
+        @selectors.each { |sel| yield sel.strip, declarations, @specificity }
+      else
+        @selectors.each { |sel| yield sel.strip, declarations, CssParser.calculate_specificity(sel) }
+      end
+    end
+
+    # Iterate through declarations.
+    def each_declaration # :yields: property, value, is_important
+      @declarations.each do |property, data|
+        value = data[:value]
+        #value += ' !important' if data[:is_important]
+        yield property.downcase.strip, value.strip, data[:is_important]
+      end
+    end
+
+    # Return all declarations as a string.
+    #--
+    # TODO: Clean-up regexp doesn't seem to work
+    #++
+    def declarations_to_s(options = {})
+     options = {:force_important => false}.merge(options)
+     str = ''
+     importance = options[:force_important] ? ' !important' : ''
+     each_declaration { |prop, val| str += "#{prop}: #{val}#{importance}; " }
+     str.gsub(/^[\s]+|[\n\r\f\t]*|[\s]+$/mx, '').strip
+    end
+
+    # Return the CSS rule set as a string.
+    def to_s
+      decs = declarations_to_s
+      "#{@selectors} { #{decs} }"
+    end
+
+    # Split shorthand declarations (e.g. +margin+ or +font+) into their constituent parts.
+    def expand_shorthand!
+      expand_dimensions_shorthand!
+      expand_font_shorthand!
+      expand_background_shorthand!
+    end
+
+    # Create shorthand declarations (e.g. +margin+ or +font+) whenever possible.
+    def create_shorthand!
+      create_background_shorthand!
+      create_dimensions_shorthand!
+      create_font_shorthand!
+    end
+
+private
+    def parse_declarations!(block) # :nodoc:
+      @declarations = {}
+
+      return unless block
+
+      block.gsub!(/(^[\s]*)|([\s]*$)/, '')
+
+      block.split(/[\;$]+/m).each do |decs|
+        if matches = decs.match(/(.[^:]*)\:(.[^;]*)(;|\Z)/i)
+          property, value, end_of_declaration = matches.captures
+
+          add_declaration!(property, value)
+        end
+      end
+    end
+
+    #--
+    # TODO: way too simplistic
+    #++
+    def parse_selectors!(selectors) # :nodoc:
+      @selectors = selectors.split(',') 
+    end
+
+    # Split shorthand dimensional declarations (e.g. <tt>margin: 0px auto;</tt>)
+    # into their constituent parts.
+    def expand_dimensions_shorthand! # :nodoc:
+      ['margin', 'padding'].each do |property|
+
+        next unless @declarations.has_key?(property)
+        
+        value = @declarations[property][:value]
+        is_important = @declarations[property][:is_important]
+        t, r, b, l = nil
+
+        matches = value.scan(CssParser::BOX_MODEL_UNITS_RX)
+
+        case matches.length
+          when 1
+            t, r, b, l = matches[0][0], matches[0][0], matches[0][0], matches[0][0]
+          when 2
+            t, b = matches[0][0], matches[0][0]
+            r, l = matches[1][0], matches[1][0]
+          when 3
+            t =  matches[0][0]
+            r, l = matches[1][0], matches[1][0]
+            b =  matches[2][0]
+          when 4
+            t =  matches[0][0]
+            r = matches[1][0]
+            b =  matches[2][0]
+            l = matches[3][0]
+        end
+
+        @declarations["#{property}-top"] = {:value => t.to_s, :is_important => is_important}
+        @declarations["#{property}-right"] = {:value => r.to_s, :is_important => is_important}
+        @declarations["#{property}-bottom"] = {:value => b.to_s, :is_important => is_important}
+        @declarations["#{property}-left"] = {:value => l.to_s, :is_important => is_important}
+        @declarations.delete(property)
+      end
+    end
+
+    # Convert shorthand font declarations (e.g. <tt>font: 300 italic 11px/14px verdana, helvetica, sans-serif;</tt>)
+    # into their constituent parts.
+    def expand_font_shorthand! # :nodoc:
+      return unless @declarations.has_key?('font')
+
+      font_props = {}
+
+      # reset properties to 'normal' per http://www.w3.org/TR/CSS21/fonts.html#font-shorthand
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height'].each do |prop|
+        font_props[prop] = 'normal'
+       end
+
+      value = @declarations['font'][:value]
+      is_important = @declarations['font'][:is_important]
+
+      in_fonts = false
+
+      matches = value.scan(/("(.*[^"])"|'(.*[^'])'|(\w[^ ,]+))/)
+      matches.each do |match|
+        m = match[0].to_s.strip
+        m.gsub!(/[;]$/, '')
+
+        if in_fonts
+          if font_props.has_key?('font-family')
+            font_props['font-family'] += ', ' + m
+          else
+            font_props['font-family'] = m
+          end
+        elsif m =~ /normal|inherit/i
+          ['font-style', 'font-weight', 'font-variant'].each do |font_prop|
+            font_props[font_prop] = m unless font_props.has_key?(font_prop)
+          end
+        elsif m =~ /italic|oblique/i
+          font_props['font-style'] = m
+        elsif m =~ /small\-caps/i
+          font_props['font-variant'] = m
+        elsif m =~ /[1-9]00$|bold|bolder|lighter/i
+          font_props['font-weight'] = m
+        elsif m =~ CssParser::FONT_UNITS_RX
+          if m =~ /\//
+            font_props['font-size'], font_props['line-height'] = m.split('/')
+          else
+            font_props['font-size'] = m
+          end
+          in_fonts = true
+        end
+      end
+
+      font_props.each { |font_prop, font_val| @declarations[font_prop] = {:value => font_val, :is_important => is_important} }
+
+      @declarations.delete('font')
+    end
+
+
+    # Convert shorthand background declarations (e.g. <tt>background: url("chess.png") gray 50% repeat fixed;</tt>)
+    # into their constituent parts.
+    #
+    # See http://www.w3.org/TR/CSS21/colors.html#propdef-background
+    def expand_background_shorthand! # :nodoc:
+      return unless @declarations.has_key?('background')
+
+      value = @declarations['background'][:value]
+      is_important = @declarations['background'][:is_important]
+
+      bg_props = {}
+
+
+      if m = value.match(Regexp.union(CssParser::URI_RX, /none/i)).to_s
+        bg_props['background-image'] = m.strip unless m.empty?
+        value.gsub!(Regexp.union(CssParser::URI_RX, /none/i), '')
+      end
+
+      if m = value.match(/([\s]*^)?(scroll|fixed)([\s]*$)?/i).to_s
+        bg_props['background-attachment'] = m.strip unless m.empty?
+      end
+
+      if m = value.match(/([\s]*^)?(repeat(\-x|\-y)*|no\-repeat)([\s]*$)?/i).to_s
+        bg_props['background-repeat'] = m.strip unless m.empty?
+      end
+
+      if m = value.match(CssParser::RE_COLOUR).to_s
+        bg_props['background-color'] = m.strip unless m.empty?
+      end
+
+      value.scan(CssParser::RE_BACKGROUND_POSITION).each do |m|
+        if bg_props.has_key?('background-position')
+          bg_props['background-position'] += ' ' + m[0].to_s.strip unless m.empty?
+        else
+          bg_props['background-position'] =  m[0].to_s.strip unless m.empty?
+        end
+      end
+
+
+      if value =~ /([\s]*^)?inherit([\s]*$)?/i
+        ['background-color', 'background-image', 'background-attachment', 'background-repeat', 'background-position'].each do |prop|
+            bg_props["#{prop}"] = 'inherit' unless bg_props.has_key?(prop) and not bg_props[prop].empty?
+        end
+      end
+
+      bg_props.each { |bg_prop, bg_val| @declarations[bg_prop] = {:value => bg_val, :is_important => is_important} }
+
+      @declarations.delete('background')
+    end
+
+
+    # Looks for long format CSS background properties (e.g. <tt>background-color</tt>) and 
+    # converts them into a shorthand CSS <tt>background</tt> property.
+    def create_background_shorthand! # :nodoc:
+      new_value = ''
+      ['background-color', 'background-image', 'background-repeat', 
+       'background-position', 'background-attachment'].each do |property|
+        if @declarations.has_key?(property)
+          new_value += @declarations[property][:value] + ' '
+          @declarations.delete(property)
+        end
+      end
+
+      unless new_value.strip.empty?
+        @declarations['background'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+      end
+    end
+
+    # Looks for long format CSS dimensional properties (i.e. <tt>margin</tt> and <tt>padding</tt>) and 
+    # converts them into shorthand CSS properties.
+    def create_dimensions_shorthand! # :nodoc:
+      # geometric
+      directions = ['top', 'right', 'bottom', 'left']
+      ['margin', 'padding'].each do |property|
+        values = {}      
+
+        foldable = @declarations.select { |dim, val| dim == "#{property}-top" or dim == "#{property}-right" or dim == "#{property}-bottom" or dim == "#{property}-left" }
+        # All four dimensions must be present
+        if foldable.length == 4
+          values = {}
+
+          directions.each { |d| values[d.to_sym] = @declarations["#{property}-#{d}"][:value].downcase.strip }
+
+          if values[:left] == values[:right]
+            if values[:top] == values[:bottom] 
+              if values[:top] == values[:left] # All four sides are equal
+                new_value = values[:top]
+              else # Top and bottom are equal, left and right are equal
+                new_value = values[:top] + ' ' + values[:left]
+              end
+            else # Only left and right are equal
+              new_value = values[:top] + ' ' + values[:left] + ' ' + values[:bottom]
+            end
+          else # No sides are equal
+            new_value = values[:top] + ' ' + values[:right] + ' ' + values[:bottom] + ' ' + values[:left]
+          end # done creating 'new_value'
+
+          # Save the new value
+          unless new_value.strip.empty?
+            @declarations[property] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+          end
+
+          # Delete the shorthand values
+          directions.each { |d| @declarations.delete("#{property}-#{d}") }
+        end
+      end # done iterating through margin and padding
+    end
+
+
+    # Looks for long format CSS font properties (e.g. <tt>font-weight</tt>) and 
+    # tries to convert them into a shorthand CSS <tt>font</tt> property.  All 
+    # font properties must be present in order to create a shorthand declaration.
+    def create_font_shorthand! # :nodoc:
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height', 'font-family'].each do |prop|
+        return unless @declarations.has_key?(prop)
+      end
+
+      new_value = ''
+      ['font-style', 'font-variant', 'font-weight'].each do |property|
+        unless @declarations[property][:value] == 'normal'
+          new_value += @declarations[property][:value] + ' '
+        end
+      end
+
+      new_value += @declarations['font-size'][:value]
+
+      unless @declarations['line-height'][:value] == 'normal'
+        new_value += '/' + @declarations['line-height'][:value]
+      end
+
+      new_value += ' ' + @declarations['font-family'][:value]
+
+      @declarations['font'] = {:value => new_value.gsub(/[\s]+/, ' ').strip}
+
+      ['font-style', 'font-variant', 'font-weight', 'font-size',
+       'line-height', 'font-family'].each do |prop|
+       @declarations.delete(prop)
+      end
+
+    end
+
+
+
+
+  end
+end

data/lib/css_parser.rb

@@ -0,0 +1,149 @@
+$:.unshift File.dirname(__FILE__)
+require 'uri'
+require 'md5'
+require 'zlib'
+require 'iconv'
+require 'css_parser/rule_set'
+require 'css_parser/regexps'
+require 'css_parser/parser'
+
+module CssParser
+  # Merge multiple CSS RuleSets by cascading according to the CSS 2.1 cascading rules 
+  # (http://www.w3.org/TR/REC-CSS2/cascade.html#cascading-order).
+  #
+  # Takes one or more RuleSet objects.
+  #
+  # Returns a RuleSet.
+  #
+  # ==== Cascading
+  # If a RuleSet object has its +specificity+ defined, that specificity is 
+  # used in the cascade calculations.  
+  #
+  # If no specificity is explicitly set and the RuleSet has *one* selector, 
+  # the specificity is calculated using that selector.
+  #
+  # If no selectors or multiple selectors are present, the specificity is 
+  # treated as 0.
+  #
+  # ==== Example #1
+  #   rs1 = RuleSet.new(nil, 'color: black;')
+  #   rs2 = RuleSet.new(nil, 'margin: 0px;')
+  #
+  #   merged = CssParser.merge(rs1, rs2)
+  #
+  #   puts merged
+  #   => "{ margin: 0px; color: black; }"
+  #
+  # ==== Example #2
+  #   rs1 = RuleSet.new(nil, 'background-color: black;')
+  #   rs2 = RuleSet.new(nil, 'background-image: none;')
+  #
+  #   merged = CssParser.merge(rs1, rs2)
+  #
+  #   puts merged
+  #   => "{ background: none black; }"
+  #--
+  # TODO: declaration_hashes should be able to contain a RuleSet
+  #       this should be a Class method
+  def CssParser.merge(*rule_sets)
+    @folded_declaration_cache = {}
+
+    # in case called like CssParser.merge([rule_set, rule_set])
+    rule_sets.flatten! if rule_sets[0].kind_of?(Array)
+    
+    unless rule_sets.all? {|rs| rs.kind_of?(CssParser::RuleSet)}
+      raise ArgumentError, "all parameters must be CssParser::RuleSets."
+    end
+
+    return rule_sets[0] if rule_sets.length == 1
+
+    # Internal storage of CSS properties that we will keep
+    properties = {}
+
+    rule_sets.each do |rule_set|
+      rule_set.expand_shorthand!
+      
+      specificity = rule_set.specificity
+      unless specificity
+        if rule_set.selectors.length == 1
+          specificity = calculate_specificity(rule_set.selectors[0])
+        else
+          specificity = 0
+        end
+      end
+
+      rule_set.each_declaration do |property, value, is_important|
+        # Add the property to the list to be folded per http://www.w3.org/TR/CSS21/cascade.html#cascading-order
+        if not properties.has_key?(property) or
+               is_important or # step 2
+               properties[property][:specificity] < specificity or # step 3
+               properties[property][:specificity] == specificity # step 4    
+          properties[property] = {:value => value, :specificity => specificity, :is_important => is_important}            
+        end
+      end
+    end
+
+    merged = RuleSet.new(nil, nil)
+
+    # TODO: what about important
+    properties.each do |property, details|
+      merged[property.strip] = details[:value].strip
+    end
+
+    merged.create_shorthand!
+    merged
+  end
+
+  # Calculates the specificity of a CSS selector
+  # per http://www.w3.org/TR/CSS21/cascade.html#specificity
+  #
+  # Returns an integer.
+  #
+  # ==== Example
+  #  CssParser.calculate_specificity('#content div p:first-line a:link')
+  #  => 114
+  #--
+  # Thanks to Rafael Salazar and Nick Fitzsimons on the css-discuss list for their help.
+  #++
+  def CssParser.calculate_specificity(selector)
+    a = 0
+    b = selector.scan(/\#/).length
+    c = selector.scan(NON_ID_ATTRIBUTES_AND_PSEUDO_CLASSES_RX).length
+    d = selector.scan(ELEMENTS_AND_PSEUDO_ELEMENTS_RX).length
+
+    (a.to_s + b.to_s + c.to_s + d.to_s).to_i
+  rescue
+    return 0
+  end
+
+  # Make <tt>url()</tt> links absolute.
+  #
+  # Takes a block of CSS and returns it with all relative URIs converted to absolute URIs.
+  #
+  # "For CSS style sheets, the base URI is that of the style sheet, not that of the source document."
+  # per http://www.w3.org/TR/CSS21/syndata.html#uri
+  #
+  # Returns a string.
+  #
+  # ==== Example
+  #  CssParser.convert_uris("body { background: url('../style/yellow.png?abc=123') };", 
+  #               "http://example.org/style/basic.css").inspect
+  #  => "body { background: url('http://example.org/style/yellow.png?abc=123') };"
+  def self.convert_uris(css, base_uri)
+    out = ''
+    base_uri = URI.parse(base_uri) unless base_uri.kind_of?(URI)
+
+    out = css.gsub(URI_RX) do |s|
+      uri = $1.to_s
+      uri.gsub!(/["']+/, '')
+      # Don't process URLs that are already absolute
+      unless uri =~ /^[a-z]+\:\/\//i
+        begin
+          uri = base_uri.merge(uri) 
+        rescue; end
+      end
+      "url('" + uri.to_s + "')"
+    end
+    out
+  end
+end

data/test/fixtures/import-circular-reference.css

@@ -0,0 +1,4 @@
+@import "import-circular-reference.css";
+
+body { color: black; background: white; }
+p { margin: 0px; }

data/test/fixtures/import-with-media-types.css

@@ -0,0 +1,3 @@
+@import "simple.css" print, tv, screen;
+
+div { color: lime; }

data/test/fixtures/import1.css

@@ -0,0 +1,3 @@
+@import 'subdir/import2.css';
+
+div { color: lime; }

data/test/fixtures/simple.css

@@ -0,0 +1,6 @@
+body {
+	color: black;
+	background: white;
+}
+
+p { margin: 0px; }

data/test/fixtures/subdir/import2.css

@@ -0,0 +1,3 @@
+@import "../simple.css";
+
+a { text-decoration: none; }

data/test/test_css_parser_basic.rb

@@ -0,0 +1,56 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test cases for reading and generating CSS shorthand properties
+class CssParserBasicTests < Test::Unit::TestCase
+  include CssParser
+
+  def setup
+    @cp = CssParser::Parser.new
+    @css = <<-EOT
+      html, body, p { margin: 0px; }
+      p { padding: 0px; }
+      #content { font: 12px/normal sans-serif; }
+    EOT
+  end
+
+  def test_finding_by_selector
+    @cp.add_block!(@css)
+    assert_equal 'margin: 0px;', @cp.find_by_selector('body').join(' ')
+    assert_equal 'margin: 0px; padding: 0px;', @cp.find_by_selector('p').join(' ')
+  end
+
+  def test_adding_block
+    @cp.add_block!(@css)
+    assert_equal 'margin: 0px;', @cp.find_by_selector('body').join
+  end
+
+  def test_adding_a_rule
+    @cp.add_rule!('div', 'color: blue;')
+    assert_equal 'color: blue;', @cp.find_by_selector('div').join(' ')
+  end
+
+  def test_adding_a_rule_set
+    rs = CssParser::RuleSet.new('div', 'color: blue;')
+    @cp.add_rule_set!(rs)
+    assert_equal 'color: blue;', @cp.find_by_selector('div').join(' ')
+  end
+
+  def test_toggling_uri_conversion
+    # with conversion
+    cp_with_conversion = Parser.new(:absolute_paths => true)
+    cp_with_conversion.add_block!("body { background: url('../style/yellow.png?abc=123') };",
+                                  :base_uri => 'http://example.org/style/basic.css')
+
+    assert_equal "background: url('http://example.org/style/yellow.png?abc=123');",
+                 cp_with_conversion['body'].join(' ')
+    
+    # without conversion
+    cp_without_conversion = Parser.new(:absolute_paths => false)
+    cp_without_conversion.add_block!("body { background: url('../style/yellow.png?abc=123') };",
+                                     :base_uri => 'http://example.org/style/basic.css')
+
+    assert_equal "background: url('../style/yellow.png?abc=123');",
+                 cp_without_conversion['body'].join(' ')
+  end
+
+end

data/test/test_css_parser_downloading.rb

@@ -0,0 +1,81 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+# Test cases for the CssParser's downloading functions.
+class CssParserDownloadingTests < Test::Unit::TestCase
+  include CssParser
+  include WEBrick
+
+  def setup
+    # from http://nullref.se/blog/2006/5/17/testing-with-webrick
+    @cp = Parser.new
+
+    @uri_base = 'http://localhost:12000'
+
+    www_root = File.dirname(__FILE__) + '/fixtures/'
+
+    @server_thread = Thread.new do
+      s = WEBrick::HTTPServer.new(:Port => 12000, :DocumentRoot => www_root, :Logger => Log.new(nil, BasicLog::ERROR), :AccessLog => [])
+      @port = s.config[:Port]
+      begin
+        s.start
+      ensure
+        s.shutdown
+      end
+    end
+
+    sleep 1 # ensure the server has time to load
+  end
+
+  def teardown
+    @server_thread.kill
+    @server_thread.join(5)
+    @server_thread = nil
+  end
+
+  def test_loading_a_remote_file
+    @cp.load_uri!("#{@uri_base}/simple.css")
+    assert_equal 'margin: 0px;', @cp.find_by_selector('p').join(' ')
+  end
+
+  def test_following_at_import_rules
+    @cp.load_uri!("#{@uri_base}/import1.css")
+
+    # from '/import1.css'
+    assert_equal 'color: lime;', @cp.find_by_selector('div').join(' ')
+
+    # from '/subdir/import2.css'
+    assert_equal 'text-decoration: none;', @cp.find_by_selector('a').join(' ')
+    
+    # from '/subdir/../simple.css'
+    assert_equal 'margin: 0px;', @cp.find_by_selector('p').join(' ')
+  end
+
+  def test_importing_with_media_types
+    @cp.load_uri!("#{@uri_base}/import-with-media-types.css")
+    
+    # from simple.css with :screen media type
+    assert_equal 'margin: 0px;', @cp.find_by_selector('p', :screen).join(' ')
+    assert_equal '', @cp.find_by_selector('p', :tty).join(' ')
+  end
+
+  def test_throwing_circular_reference_exception
+    assert_raise CircularReferenceError do
+      @cp.load_uri!("#{@uri_base}/import-circular-reference.css")
+    end
+  end
+
+  def test_toggling_not_found_exceptions
+    cp_with_exceptions = Parser.new(:io_exceptions => true)
+
+    assert_raise RemoteFileError do
+      cp_with_exceptions.load_uri!("#{@uri_base}/no-exist.xyz")
+    end
+
+    cp_without_exceptions = Parser.new(:io_exceptions => false)
+
+    assert_nothing_raised RemoteFileError do
+      cp_without_exceptions.load_uri!("#{@uri_base}/no-exist.xyz")
+    end
+  end
+
+end