archetype 0.0.1.pre.3.90263a7 → 0.0.1.pre.3.811928f

data/lib/archetype/sass_extensions/functions/styleguide.rb

@@ -15,13 +15,10 @@ module Archetype::SassExtensions::Styleguide
   DEFAULT     = 'default'
   REGEX       = 'regex'
   SPECIAL     = %w(states selectors)
-  DROPALL     = %w(all true)
   # these are unique CSS keys that can be exploited to provide fallback functionality by providing a second value
   # e.g color: red; color: rgba(255,0,0, 0.8);
-  FALLBACKS   = %w(background background-image background-color border border-bottom border-bottom-color border-color border-left border-left-color border-right border-right-color border-top border-top-color clip color layer-background-color outline outline-color white-space extend)
-  # these are mixins that make sense to run multiple times within a block
-  MULTIMIXINS = %w(target-browser)
-  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE] + MULTIMIXINS
+  FALLBACKS   = %w(background background-image background-color border border-bottom border-bottom-color border-color border-left border-left-color border-right border-right-color border-top border-top-color clip color layer-background-color outline outline-color white-space)
+  ADDITIVES   = FALLBACKS + [DROP, INHERIT, STYLEGUIDE]
   @@archetype_styleguide_mutex = Mutex.new
   # :startdoc:
 
@@ -79,7 +76,7 @@ module Archetype::SassExtensions::Styleguide
       extensions = theme[:extensions]
       return Sass::Script::Bool.new(false) if component_exists(id, theme, extension, force)
       extensions.push(extension)
-      components[id] = (components[id] ||= Archetype::Hash.new).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
+      components[id] = (components[id] ||= {}).rmerge(helpers.list_to_hash(data, 1, SPECIAL, ADDITIVES))
       return Sass::Script::Bool.new(true)
     end
   end
@@ -101,7 +98,7 @@ module Archetype::SassExtensions::Styleguide
   #
   def styleguide_component_exists(id, theme = nil, extension = nil, force = false)
     @@archetype_styleguide_mutex.synchronize do
-      extension = helpers.to_str(extension).hash if not extension.nil?
+      extension = helpers.to_str(extension) if not extension.nil?
       return Sass::Script::Bool.new( component_exists(id, theme, extension, force) )
     end
   end
@@ -226,34 +223,29 @@ private
   #
   def extract_styles(id, modifiers, strict = false, theme = nil, context = nil)
     theme = get_theme(theme)
-    context ||= theme[:components][id] || Archetype::Hash.new
+    context ||= theme[:components][id] || {}
     modifiers = helpers.to_str(modifiers)
-    return Archetype::Hash.new if context.nil? or context.empty?
+    return {} if context.nil? or context.empty?
     # push on the defaults first
-    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || Archetype::Hash.new
+    out = (strict ? resolve_dependents(id, context[modifiers], theme[:name], context) : context[DEFAULT]) || {}
     out = out.clone
     # if it's not strict, find anything that matched
     if not strict
       modifiers = modifiers.split
-      context.each do |key, definition|
-        definition = [key, definition]
+      context.each do |definition|
         modifier = definition[0]
         if modifier != DEFAULT
           match = true
           modifier = modifier.split
           if modifier[0] == REGEX
             # if it's a regex pattern, test if it matches
-            match = modifiers.join(' ') =~ /#{modifier[1].gsub(/\A"|"\Z/, '')}/i
+            match = modifiers.join(' ') =~ /#{modifiers[1].gsub(/\A"|"\Z/, '')}/i
           else
             # otherwise, if the modifier isn't in our list of modifiers, it's not valid and just move on
             modifier.each { |i| match = false if not modifiers.include?(i) }
           end
           # if it matched, process it
-          if match
-            tmp = resolve_dependents(id, definition[1], theme[:name], nil, out)
-            out, tmp = post_resolve_drops(out, tmp)
-            out = out.rmerge(tmp)
-          end
+          out = out.rmerge(resolve_dependents(id, definition[1], theme[:name], nil, out.keys)) if match
         end
       end
     end
@@ -261,19 +253,15 @@ private
     # this lets us define special states and elements
     SPECIAL.each do |special_key|
       if out.is_a? Hash
-        special = out[special_key] || Archetype::Hash.new
-        if special == 'nil'
-          out[special_key] = Archetype::Hash.new
-        else
-          tmp = Archetype::Hash.new
-          special.each { |key, value| tmp[key] = extract_styles(key, key, true, theme[:name], special) }
-          out[special_key] = tmp if not tmp.empty?
-        end
+        special = out[special_key]
+        tmp = {}
+        (special || {}).each { |key, value| tmp[key] = extract_styles(key, key, true, theme[:name], special) }
+        out[special_key] = tmp if not tmp.empty?
       end
     end
     # check for nested styleguides
     styleguide = out[STYLEGUIDE]
-    if not (styleguide.nil? or styleguide.empty?)
+    if styleguide and not styleguide.empty?
       styles = get_styles(styleguide, theme[:name])
       out.delete(STYLEGUIDE)
       out = styles.rmerge(out)
@@ -281,87 +269,6 @@ private
     return out
   end
 
-  #
-  # given two objects, resolve the chain of dropped styles
-  #  this runs after having already resolved the dropped styles and merged
-  #
-  # *Parameters*:
-  # - <tt>obj</tt> {Hash} the source object
-  # - <tt>merger</tt> {Hash} the object to be merged in
-  # *Returns*:
-  # - {Array.<Hash>} the resulting `obj` and `merger` objects
-  #
-  def post_resolve_drops(obj, merger)
-    return [obj, merger] if obj.nil? or merger.nil?
-    drop = merger[DROP]
-    keys = obj.keys
-    if not drop.nil?
-      drop.to_a.each do |key|
-        key = helpers.to_str(key)
-        obj.delete(key) if not SPECIAL.include?(key)
-      end
-      merger.delete(DROP)
-    else
-    end
-    SPECIAL.each do |special|
-      if obj[special].is_a?(Hash) and merger[special].is_a?(Hash)
-        obj[special], merger[special] = post_resolve_drops(obj[special], merger[special])
-      end
-    end
-    return [obj, merger]
-  end
-
-  #
-  # given two objects, resolve the chain of dropped styles
-  #
-  # *Parameters*:
-  # - <tt>value</tt> {Hash} the source object
-  # - <tt>obj</tt> {Hash} the object to be merged in
-  # - <tt>is_special</tt> {Boolean} whether this is from a SPECIAL branch of a Hash
-  # *Returns*:
-  # - {Array.<Hash>} the resulting value
-  #
-  def resolve_drops(value, obj, is_special = false)
-    return value if not (value.is_a?(Hash) and obj.is_a?(Hash))
-    keys = obj.keys
-    drop = value[DROP]
-    if not drop.nil?
-      tmp = Archetype::Hash.new
-      if DROPALL.include?(helpers.to_str(drop))
-        if not keys.nil?
-          keys.each do |key|
-            if SPECIAL.include?(key)
-              if not (obj[key].nil? or obj[key].empty?)
-                tmp[key] = Archetype::Hash.new
-                tmp[key][DROP] = obj[key].keys
-              end
-            else
-              tmp[key] = 'nil'
-            end
-          end
-        end
-      else
-        drop.to_a.each do |key|
-          key = helpers.to_str(key)
-          if SPECIAL.include?(key)
-            if not (obj[key].nil? or obj[key].empty?)
-              tmp[key] = Archetype::Hash.new
-              tmp[key][DROP] = obj[key].keys
-            end
-          else
-            tmp[key] = 'nil'
-          end
-        end
-      end
-      value.delete(DROP) if not is_special
-      value = tmp.rmerge(value)
-    end
-    value.each do |key|
-      value[key] = resolve_drops(value[key], obj[key], key, SPECIAL.include?(key)) if not value[key].nil?
-    end
-    return value
-  end
-
   #
   # resolve any dependent references from the component
   #
@@ -374,19 +281,33 @@ private
   # *Returns*:
   # - {Hash} a hash of the resolved styles
   #
-  def resolve_dependents(id, value, theme = nil, context = nil, obj = nil)
+  def resolve_dependents(id, value, theme = nil, context = nil, keys = nil)
     # we have to create a clone here as the passed in value is volatile and we're performing destructive changes
     value = value.clone
     # check that we're dealing with a hash
     if value.is_a?(Hash)
       # check for dropped styles
-      value = resolve_drops(value, obj)
-
+      drop = value[DROP]
+      if not drop.nil?
+        tmp = {}
+        if %w(all true).include?(helpers.to_str(drop)) and not keys.nil? and not keys.empty?
+          keys.each do |key|
+            tmp[key] = 'nil'
+          end
+        else
+          drop = drop.to_a
+          drop.each do |key|
+            tmp[helpers.to_str(key)] = 'nil'
+          end
+        end
+        value.delete(DROP)
+        value = tmp.rmerge(value)
+      end
       # check for inheritance
       inherit = value[INHERIT]
-      if not (inherit.nil? or inherit.empty?)
+      if inherit and not inherit.empty?
         # create a temporary object and extract the nested styles
-        tmp = Archetype::Hash.new
+        tmp = {}
         inherit.each { |related| tmp = tmp.rmerge(extract_styles(id, related, true, theme, context)) }
         # remove the inheritance key and update the styles
         value.delete(INHERIT)
@@ -427,8 +348,9 @@ private
   #
   def get_styles(description, theme = nil, state = 'false')
     state = helpers.to_str(state)
-    styles = Archetype::Hash.new
-    description.to_a.each do |sentence|
+    description = description.to_a
+    styles = {}
+    description.each do |sentence|
       # get the grammar from the sentence
       id, modifiers, token = grammar(sentence, theme, state)
       if id

data/lib/archetype/sass_extensions/functions/ui.rb

@@ -18,11 +18,10 @@ module Archetype::SassExtensions::UI
   # - {String} the unique string
   #
   def unique(prefix = '')
-    prefix = helpers.to_str(prefix, ' ', :quotes)
+    prefix = helpers.to_str(prefix).gsub(/\A"|"\Z/, '')
     prefix = '.' if prefix == 'class'
     prefix = '#' if prefix == 'id'
-    suffix = Compass.configuration.testing ? "RANDOM_UID" : "#{Time.now.to_i}-#{rand(36**8).to_s(36)}-#{uid}"
-    return Sass::Script::String.new("#{prefix}archetype-uid-#{suffix}")
+    return Sass::Script::String.new("#{prefix}archetype-uid-#{uid}")
   end
 
   #

data/lib/archetype/sass_extensions/functions/version.rb

@@ -8,7 +8,7 @@ require 'sass/version'
 #
 module Archetype::SassExtensions::Version
   # :stopdoc:
-  COMPARATOR_PATTERN  = /(\s[neqglt]+\s|[><=!]+)/
+  COMPARATOR_PATTERN  = /([neglt]+|[><=!]+)/
   VERSION_PATTERN     = /\d+(\.\d+)*(\.[x|\*])?/
   # :startdoc:
 
@@ -21,15 +21,10 @@ module Archetype::SassExtensions::Version
   # - {String|Boolean} if no test or test is just a lookup of a framework, it returns the version of that framework, otherwise it returns the result of the test
   #
   def archetype_version(test = nil)
-    test = test.nil? ? 'archetype' : helpers.to_str(test, ' ', :quotes).downcase
-    lib = ''
-    if test.include?('compass')
-      lib = Compass::VERSION
-    elsif test.include?('sass')
-      lib = Sass::VERSION
-    else
-      lib = Archetype::VERSION
-    end
+    test = test.nil? ? 'archetype' : helpers.to_str(test).gsub(/\A"|"\Z/, '').downcase
+    lib = Archetype::VERSION
+    lib = Compass::VERSION if test.include?('compass')
+    lib = Sass::VERSION if test.include?('sass')
     # strip off any non-official versioning (e.g. pre/alpha/rc)
     lib = lib.match(VERSION_PATTERN)[0]
     result = compare_version(lib, test.match(VERSION_PATTERN), test.match(COMPARATOR_PATTERN))
@@ -60,7 +55,7 @@ private
     # check for wild cards
     wild = version.index('x')
     # check the comparison
-    comparator = ((comparator || [])[0] || 'eq').strip
+    comparator = (comparator || [])[0] || 'eq'
     eq = comparator =~ /(e|=)/
     lt = comparator =~ /(l|<)/
     gt = comparator =~ /(g|>)/

data/lib/archetype/version.rb

@@ -10,7 +10,7 @@ module Archetype
     # Method borrowed from Compass. All credit goes to Chris Eppstein and other contributors
     # https://github.com/chriseppstein/compass/blob/stable/lib/compass/version.rb
     # \(This method swiped from Haml and then modified, some credit goes to Nathan Weizenbaum\)
-    #
+    # 
     # *Returns*:
     # - {String} the version of Archetype
     #
@@ -29,25 +29,18 @@ module Archetype
 
     def read_version
       require 'yaml'
-      begin
-        @version = YAML.load(File.read(scope('VERSION.yml')))
-        @version[:teeny] = @version[:patch]
-        @version[:string] = "#{@version[:major]}.#{@version[:minor]}"
-        @version[:string] << ".#{@version[:patch]}" if @version[:patch]
-        @version[:string] << ".#{@version[:build]}" if @version[:build]
-        @version[:string] << ".#{@version[:state]}" if @version[:state]
-        @version[:string] << ".#{@version[:iteration]}" if @version[:iteration]
-        if !ENV['OFFICIAL'] && r = revision
-          @version[:string] << ".#{r[0..6]}"
-          @version[:rev] = r
-        end
-        return @version
-      rescue
-        # this is a hack, but I'm not fully understanding how to fix this correctly
-        # see issue #4
-        # if it failed, try again, for now
-        return read_version
+      @version = YAML::load(File.read(scope('VERSION.yml')))
+      @version[:teeny] = @version[:patch]
+      @version[:string] = "#{@version[:major]}.#{@version[:minor]}"
+      @version[:string] << ".#{@version[:patch]}" if @version[:patch]
+      @version[:string] << ".#{@version[:build]}" if @version[:build]
+      @version[:string] << ".#{@version[:state]}" if @version[:state]
+      @version[:string] << ".#{@version[:iteration]}" if @version[:iteration]
+      if !ENV['OFFICIAL'] && r = revision
+        @version[:string] << ".#{r[0..6]}"
+        @version[:rev] = r
       end
+      @version
     end
 
     def revision

data/stylesheets/archetype/_base.scss

@@ -38,9 +38,6 @@ $RESET_INIT: false !default;
   // the font-face mixin will likely change in a future version, keep an eye on this
   // https://github.com/chriseppstein/compass/issues/867
   @include font-face($CONFIG_GLYPHS_NAME, $CONFIG_GLYPHS_FILES, $CONFIG_GLYPHS_EOT, $CONFIG_GLYPHS_WEIGHT, $CONFIG_GLYPHS_STYLE);
-  // output a second @font-face set with a versioned family name
-  // this will help avoid collisions when multi-app CSS is loaded on a single page
-  @include font-face('#{$CONFIG_GLYPHS_NAME}-#{$CONFIG_GLYPHS_VERSION}', $CONFIG_GLYPHS_FILES, $CONFIG_GLYPHS_EOT, $CONFIG_GLYPHS_WEIGHT, $CONFIG_GLYPHS_STYLE);
 }
 
 // auto invoke base reset

data/stylesheets/archetype/_config.scss

@@ -40,14 +40,13 @@ $CONTENT_PLACEHOLDER:             '\0020' !default;
 $CONFIG_DISABLED_CSS:             () !default;                                                      // a list of CSS3 features to always disable when using output-style()
 $CONFIG_GENERATED_TAG_PREFIX:     x-archetype !default;                                             // the prefix for the tag name to create when using ie-pseudo method
 $CONFIG_GENERATED_TAG_CSS:        false !default;                                                   // styles to apply to the generated tag when using ie-pseudo method (use this as a way to reset styles on these tags)
-$CONFIG_GENERATED_TAG_INLINE:     true !default;                                                    // if `true` insert the styles inline on the generated tag, otherwise insert the styles in a unique css rule
 
 // z-layers
 $CONFIG_Z_INDEX_BASE:             0 !default;                                                       // the default starting layer for z-index calculations
 $CONFIG_Z_LAYERS_OFFSET:          100 !default;                                                     // the offset between z-layers
 $CONFIG_Z_LAYERS:                 (default dialog navigation) !default;                             // the orders for the z-layers
 
-// compass
+// compass 
 $COMPASS_RTL_SUPPORT:             false !default;                                                   // does your Compass version support RTL? set to true if Compass mixins support RTL
 
 // sprites
@@ -59,7 +58,6 @@ $CONFIG_KEYFRAME_LOADERS:         archetype-loader !default;
 
 // glyphs
 $CONFIG_GLYPHS_NAME:              FontAwesome !default;                                             // name for the font-face
-$CONFIG_GLYPHS_VERSION:           '0.0.1' !default;                                                 // the glyph library version number
 $CONFIG_GLYPHS_SVG_ID:            $CONFIG_GLYPHS_NAME !default;
 $CONFIG_GLYPHS_BASE_PATH:         'vendor/archetype/fontawesome-webfont' !default;                  // generic path to all glpyh fonts (sans extensions)
 $CONFIG_GLYPHS_EOT:               '#{$CONFIG_GLYPHS_BASE_PATH}.eot' !default;
@@ -306,12 +304,12 @@ $CONFIG_BROWSER_WARN_ON_HACK:     false !default;
 $CONFIG_BROWSER_VENDORS_HACK: (
   (webkit-all, safari webkit chrome),
   (gecko-all,  firefox gecko mozilla),
-  (opera-all,  opera) // NOTE: this may stop working once Opera switches over to using WebKit/Blink
+  (opera-all,  opera)
 ) !default;
 
 // os targeting
 $CONFIG_OS_VENDORS_CLASS: (
-  (os-win,   windows win winxp win7 win8),
+  (os-win,   windows win winxp win7),
   (os-mac,   apple mac osx),
   (os-linux, linux),
   (os-other, other misc unknown)
@@ -323,30 +321,21 @@ $CORE_SAFE_FONTS: (
   (sans-serif, (
     (default, (
       (default          (sans-serif)),
-      (ko_KR            ('Malgun Gothic', default)),
-      (zh_TW            (SimSun, default)),
-      (zh_CN            (SimSun, default))
+      (ko_KR            ('Malgun Gothic', default))
     )),
     (win, (
       (default          (Arial, sans-serif)),
       (ja_JP            (メイリオ, Meiryo, 'ＭＳ Ｐゴシック', 'MS PGothic', default)),
-      (zh_TW            (default, '微軟正黑體', 'Microsoft JhengHei', PMingLiu, '宋体', SimSun)),
-      (zh_CN            (default, '华文细黑', 'STHeiti Light', '微软雅黑体', 'Microsoft Yahei', '新宋体', NSimSun, '宋体', SimSun)),
       (ko_KR            nil)
     )),
     (mac, (
       (default          (Helvetica, Arial, sans-serif)),
-      (zh_TW            (default, '黑體-繁', 'Heiti TC', '儷黑Pro', 'LiHei Pro', PMingLiu, '宋体', SimSun)),
-      (zh_CN            (default, '黑体-简', 'Heiti SC', '华文细黑', 'STHeiti Light', '华文黑体', STHeiti)),
       (ja_JP            ('Hiragino Kaku Gothic Pro', 'ヒラギノ角ゴ Pro W3', 'ＭＳ Ｐゴシック', 'MS PGothic', default)),
       (ko_KR            nil)
     )),
     (linux, (
       (default          (Helvetica, FreeSans, 'Liberation Sans', Helmet, Arial, sans-serif)),
-      (zh_TW            (default, PMingLiu, '宋体', SimSun)),
-      (zh_CN            (default, '新宋体', NSimSun, '宋体', SimSun)),
-      (ja_JP            nil),
-      (ko_KR            nil)
+      (CJK              nil)
     ))
   )),
   (serif, (
@@ -366,9 +355,3 @@ $CORE_SAFE_FONTS: (
 ); // note that this declaration isn't a `default`, but rather is enforced everytime. this can be modified (via extending $CONFIG_SAFE_FONTS)
 $CONFIG_SAFE_FONTS: () !default;
 $CONFIG_SAFE_FONTS: associative-merge($CORE_SAFE_FONTS, $CONFIG_SAFE_FONTS);
-
-$archetype-glyph-selector: false !default;
-$archetype-pseudo-selector: false !default;
-
-$CORE_GLYPH_SELECTOR_VAR: '$archetype-glyph-selector';
-$CORE_GLYPH_SELECTOR_VAR: '$archetype-pseudo-selector';

data/stylesheets/archetype/_hacks.scss

@@ -34,83 +34,42 @@
 }
 
 // proxy for ie-pseudo
-// @mixin     ie-pseudo-before
-// @param     $styles {String} the styles to apply to the pseudo-element
-// @param     $content {String} the content to insert into the element (similar to css `content` attribute)
-// @param     $name {String} the name of the element
-// @content
+// @mixin    ie-pseudo-before
+// @param    $styles {String} the styles to apply to the pseudo-element
+// @param    $content {String} the content to insert into the element (similar to css `content` attribute)
+// @param    $name {String} the name of the element
 @mixin ie-pseudo-before($styles: false, $content: false, $name: '') {
-  @if archetype-version('Sass >= 3.2') {
-    @include ie-pseudo($styles, $content, before, $name) {
-      @content;
-    }
-  }
-  @else {
-    @include ie-pseudo($styles, $content, before, $name);
-  }
+  @include ie-pseudo($styles, $content, before, $name);
 }
 
 // proxy for ie-pseudo
-// @mixin     ie-pseudo-after
-// @param     $styles {String} the styles to apply to the pseudo-element
-// @param     $content {String} the content to insert into the element (similar to css `content` attribute)
-// @param     $name {String} the name of the element
-// @content
+// @mixin    ie-pseudo-after
+// @param    $styles {String} the styles to apply to the pseudo-element
+// @param    $content {String} the content to insert into the element (similar to css `content` attribute)
+// @param    $name {String} the name of the element
 @mixin ie-pseudo-after($styles: false, $content: false, $name: '') {
-  @if archetype-version('Sass >= 3.2') {
-    @include ie-pseudo($styles, $content, after, $name) {
-      @content;
-    }
-  }
-  @else {
-    @include ie-pseudo($styles, $content, after, $name);
-  }
+  @include ie-pseudo($styles, $content, after, $name);
 }
 
-// this creates a one-time executing expression that inserts an element relative to `this` element.
+// this creates a one-type executing expression that inserts an element relative to `this` element.
 // this allows some level of support for :before/:after in IE6/7
 // inspired by http://nicolasgallagher.com/better-float-containment-in-ie/
-// @mixin     ie-pseudo
-// @param     $styles {String} the styles to apply to the pseudo-element
-// @param     $content {String} the content to insert into the element (similar to css `content` attribute)
-// @param     $placement {String} [before|after] simulate :before or :after behavior
-// @param     $name {String} the name of the element
-// @param     $uid {String} a custom, unique identifier for the generate element
-// @content
-@mixin ie-pseudo($styles: false, $content: false, $placement: before, $name: '', $uid: false) {
-  $archetype-pseudo-selector: false;
+// @mixin    ie-pseudo
+// @param    $styles {String} the styles to apply to the pseudo-element
+// @param    $content {String} the content to insert into the element (similar to css `content` attribute)
+// @param    $placement {String} [before|after] simulate :before or :after behavior
+// @param    $name {String} the name of the element
+@mixin ie-pseudo($styles: false, $content: false, $placement: before, $name: '') {
   @if $legacy-support-for-ie6 or $legacy-support-for-ie7 {
-    $uid: if($uid, $uid, unique('ie-pseudo-'));
-    $archetype-pseudo-selector: '& ##{$uid}';
     $method: if($placement == before, insertBefore, appendChild);
     $content: if($content and $content != nil, 'this.el.innerHTML="#{-ie-pseudo-content($content)}",', '');
     @if $CONFIG_GENERATED_TAG_CSS {
       $styles: if($styles and $styles != nil, #{$CONFIG_GENERATED_TAG_CSS}#{$styles}, $CONFIG_GENERATED_TAG_CSS);
     }
-    // if we're using inline styles...
-    $inline: if($styles and $styles != nil and $CONFIG_GENERATED_TAG_INLINE, 'this.el.style.cssText="#{$styles}",', '');
-    *zoom: expression(this.runtimeStyle.zoom="1", this.el=document.createElement("#{prefixed-tag($name)}"),this.el.id="#{$uid}",#{$content}#{$inline}this.#{$method}(this.el));
-    // if we're NOT using inline styles...
-    @if not $CONFIG_GENERATED_TAG_INLINE {
-      // output it on the generated selector
-      #{$archetype-pseudo-selector} {
-        @include to-styles(-style-string-to-list(unquote($styles)));
-        @if archetype-version('Sass >= 3.2') {
-          @content;
-        }
-      }
+    $styles: if($styles and $styles != nil, 'this.el.style.cssText="#{$styles}",', '');
+    @if $name != '' {
+      $name: '-#{$name}';
     }
-  }
-}
-
-// a hack that allows elements with transparent backgrounds to be focusable in IE
-// @mixin     transparent-focusable
-// @param     $url {String} an optional URL to point to an image (not required)
-// @param     $data {String} an optional data URI for a transparent image (not required)
-@mixin transparent-focusable($url: url(https://), $data: 'data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7') {
-  $bg: (transparent);
-  background: append($bg, $data);
-  @if $url {
-    @include target-browser(ie lte 7, background, append($bg, $url));
+    *zoom: expression(this.runtimeStyle.zoom="1", this.el=document.createElement("#{$CONFIG_GENERATED_TAG_PREFIX}#{$name}"),#{$content}#{$styles}this.#{$method}(this.el));
   }
 }