/*  Copyright: 2006-2007 Mark Wubben.
    Author: Mark Wubben, <http://novemberborn.net/>
*/

var parseSelector = (function() {
  var SEPERATOR       = /\s*,\s*/
  var WHITESPACE      = /\s*([\s>+~(),]|^|$)\s*/g;
  var IMPLIED_ALL     = /([\s>+~,]|[^(]\+|^)([#.:@])/g;
  var STANDARD_SELECT = /^[^\s>+~]/;
  var STREAM          = /[\s#.:>+~()@]|[^\s#.:>+~()@]+/g;
  
  function parseSelector(selector, node) {
    node = node || document.documentElement;
    var argSelectors = selector.split(SEPERATOR), result = [];
    
    for(var i = 0; i < argSelectors.length; i++) {
      var nodes = [node], stream = toStream(argSelectors[i]);
      for(var j = 0; j < stream.length;) {
        var token = stream[j++], filter = stream[j++], args = '';
        if(stream[j] == '(') {
          while(stream[j++] != ')' && j < stream.length) args += stream[j];
          args = args.slice(0, -1);
        }
        nodes = select(nodes, token, filter, args);
      }
      result = result.concat(nodes);
    }
    
    return result;
  }

  function toStream(selector) {
    var stream = selector.replace(WHITESPACE, '$1').replace(IMPLIED_ALL, '$1*$2');
    if(STANDARD_SELECT.test(stream)) stream = ' ' + stream;
    return stream.match(STREAM) || [];
  }
  
  function select(nodes, token, filter, args) {
    return (parseSelector.selectors[token]) ? parseSelector.selectors[token](nodes, filter, args) : [];
  }
  
  var util = {
    toArray: function(enumerable) {
      var a = [];
      for(var i = 0; i < enumerable.length; i++) a.push(enumerable[i]);
      return a;
    }
  };
  
  var dom = {
    isTag: function(node, tag) {
      return (tag == '*') || (tag.toLowerCase() == node.nodeName.toLowerCase());
    },
  
    previousSiblingElement: function(node) {
      do node = node.previousSibling; while(node && node.nodeType != 1);
      return node;
    },
  
    nextSiblingElement: function(node) {
      do node = node.nextSibling; while(node && node.nodeType != 1);
      return node;
    },
  
    hasClass: function(name, node) {
      return (node.className || '').match('(^|\\s)'+name+'(\\s|$)');
    },
  
    getByTag: function(tag, node) {
      return node.getElementsByTagName(tag);
    }
  };

  var selectors = {
    '#': function(nodes, filter) {
      for(var i = 0; i < nodes.length; i++) {
        if(nodes[i].getAttribute('id') == filter) return [nodes[i]];
      }
      return [];
    },

    ' ': function(nodes, filter) {
      var result = [];
      for(var i = 0; i < nodes.length; i++) {
        result = result.concat(util.toArray(dom.getByTag(filter, nodes[i])));
      }
      return result;
    },
    
    '>': function(nodes, filter) {
      var result = [];
      for(var i = 0, node; i < nodes.length; i++) {
        node = nodes[i];
        for(var j = 0, child; j < node.childNodes.length; j++) {
          child = node.childNodes[j];
          if(child.nodeType == 1 && dom.isTag(child, filter)) result.push(child);
        }
      }
      return result;
    },

    '.': function(nodes, filter) {
      var result = [];
      for(var i = 0, node; i < nodes.length; i++) {
        node = nodes[i];
        if(dom.hasClass([filter], node)) result.push(node);
      }
      return result;
    }, 
        
    ':': function(nodes, filter, args) {
      return (parseSelector.pseudoClasses[filter]) ? parseSelector.pseudoClasses[filter](nodes, args) : [];
    }
    
  };

  parseSelector.selectors     = selectors;
  parseSelector.pseudoClasses = {};
  parseSelector.util          = util;
  parseSelector.dom           = dom;

  return parseSelector;
})();


var sIFR = new function() {
  //=:private Constant reference to the Singleton instance
  var SIFR = this;

  var CSS_ACTIVE           = 'sIFR-active';
  var CSS_UNLOADING        = 'sIFR-unloading';
  var CSS_REPLACED         = 'sIFR-replaced';
  var CSS_FLASH            = 'sIFR-flash';
  var CSS_IGNORE           = 'sIFR-ignore';
  var CSS_ALTERNATE        = 'sIFR-alternate';
  var CSS_CLASS            = 'sIFR-class';
  var CSS_LAYOUT           = 'sIFR-layout';
  var CSS_FIX_FOCUS        = 'sIFR-fixfocus'
  var CSS_DUMMY            = 'sIFR-dummy';
  var CSS_ZOOM_DETECT      = 'sIFR-zoomdetect';
  var MIN_FONT_SIZE        = 6;
  var MAX_FONT_SIZE        = 126;
  var MIN_FLASH_VERSION    = 8;
  var PREFETCH_COOKIE      = 'SIFR-PREFETCHED';
  //= Whitespace string each whitespace character is replaced with, as per `preserveSingleWhitespace`.
  var DEFAULT_RATIOS       = [];
  var FLASH_PADDING_BOTTOM = 5;
  var VERSION              = 'beta2';

  this.isActive                 = false;
  this.isEnabled                = true;
  this.preserveSingleWhitespace = false;
  this.fixWrap                  = false;
  this.fixHover                 = true;
  this.autoInitialize           = true;
  this.setPrefetchCookie        = true;
  this.cookiePath               = '/';
  this.domains                  = [];
  this.fromLocal                = false;
  this.forceClear               = false;
  this.forceWidth               = true;
  this.fitExactly               = false;
  this.forceTextTransform       = true;
  this.useDomLoaded             = true;
  this.useStyleCheck            = false;
  this.hasFlashClassSet         = false;
  this.repaintOnResize          = true;
  this.callbacks                = [];
  
  var elementCount = 0; // The number of replaced elements.
  var hasPrefetched = false, isInitialized = false;

  var dom = new function() {
    var XHTML_NS = 'http://www.w3.org/1999/xhtml';
      
    this.getBody = function() {
      var nodes = document.getElementsByTagName('body');
      if(nodes.length == 1) return nodes[0];
      return null;
    };

    this.addClass = function(name, node) {
      if(node) node.className = ((node.className || '') == '' ? '' : node.className + ' ') + name;
    };
    
    this.removeClass = function(name, node) {
      if(node) node.className = node.className.replace(new RegExp('(^|\\s)' + name + '(\\s|$)'), '').replace(/^\s+|(\s)\s+/g, '$1');
    };

    this.hasClass = function(name, node) {
      return new RegExp('(^|\\s)' + name + '(\\s|$)').test(node.className);
    };
    
    this.hasOneOfClassses = function(names, node) {
      for(var i = 0; i < names.length; i++) {
        if(this.hasClass(names[i], node)) return true;
      }
      return false;
    };

    this.create = function(name) {
      if(document.createElementNS) return document.createElementNS(XHTML_NS, name);
      return document.createElement(name);
    };
    
    this.nodeFromHtml = function(html) {
      var temp = this.create('div');
      temp.innerHTML = html;
      return temp.firstChild;
    };
    
    this.getComputedStyle = function(node, property) {
      var result;
      if(document.defaultView && document.defaultView.getComputedStyle) {
        result = document.defaultView.getComputedStyle(node, null)[property];
      } else if(node.currentStyle) result = node.currentStyle[property];
      return result || ''; // Ensuring a string.
    };

    this.getStyleAsInt = function(node, property, requirePx) {
      var value = this.getComputedStyle(node, property);
      if(requirePx && !/px$/.test(value)) return 0;
      
      value = parseInt(value);
      return isNaN(value) ? 0 : value;
    };
    
    this.getWidthFromStyle = function(node) {
      var width = this.getStyleAsInt(node, 'width', ua.ie);
      if(width == 0) {
        var paddingRight  = this.getStyleAsInt(node, 'paddingRight', true);
        var paddingLeft   = this.getStyleAsInt(node, 'paddingLeft', true);
        var borderRight   = this.getStyleAsInt(node, 'borderRightWidth', true);
        var borderLeft    = this.getStyleAsInt(node, 'borderLeftWidth', true);
        width = node.offsetWidth - paddingLeft - paddingRight - borderLeft - borderRight;
      }
      return width;
    };

    this.blurElement = function(element) {
      if (ua.gecko) {
        // This can only be done in Gecko
        element.blur();
        return;
      }
      
      // Move the focus to an input element, and then destroy it.
      var input = dom.create('input');
      input.style.width = '0px';
      input.style.height = '0px';
      element.parentNode.appendChild(input);
      input.focus();
      input.blur();
      input.parentNode.removeChild(input);
    };
    
    this.getDimensions = function(node) {
      var width = node.offsetWidth;
      var height = node.offsetHeight;
      
      if(width == 0 || height == 0) {
        for(var i = 0; i < node.childNodes.length; i++) {
          var child = node.childNodes[i];
          if(child.nodeType != 1) continue;
          width = Math.max(width, child.offsetWidth);
          height = Math.max(height, child.offsetHeight);
        }
      }
      
      return {width: width, height: height};
    };
    
    this.contentIsLink = function(node) {
      var linkFound = false;
      for(var i = 0; i < node.childNodes.length; i++) {
        var child = node.childNodes[i];
        if(child.nodeType == 3 && !child.nodeValue.match(/^\s*$/)) return false;
        else if(child.nodeType != 1) continue;

        var isLink = child.nodeName.toLowerCase() == 'a';
        if(!isLink) return false;
        else linkFound = true;
      }
      return linkFound;
    };
    
    var dom = this;
    this.swf = {
      create: function(builder, fixFocus, id, width, height, src, vars, wmode, backgroundColor) {
        var obj = builder.object(fixFocus, id, src, width, height);
        return builder.params(obj, 'flashvars', vars, 'wmode', wmode, 'bgcolor', backgroundColor, 
                              'allowScriptAccess', 'always', 'quality', 'best');
      },
      
      ie: {
        // fixFocus is not supported for IE.
        object: function(fixFocus, id, src, width, height) {
          return '<object classid="clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" id="' + id +
           '" width="' + width + '" height="' + height + '" class="' + CSS_FLASH + '">' +
           '<param name="movie" value="' + src + '"></param></object>' +
           // Load in the callback code. Keep the <script> line exactly the same!!! (Yes, IE is that crappy)
           // Thanks to Tom Lee for the tip: <http://tom-lee.blogspot.com/2006/04/dynamically-inserting-fscommand.html>
           '<scr' + 'ipt event=FSCommand(info,args) for=' + id + '>' +
             id + '_DoFSCommand(info, args);' +
           '</' + 'script>' // End like this to prevent syntax error in IE/Mac.
           ;
        },

        params: function(obj) {
          var params = '';
          for(var i = 1; i < arguments.length; i+=2) {
            params += '<param name="' + arguments[i] + '" value="' + arguments[i + 1] + '"></param>';
          }
          return obj.replace(/(<\/object>)/, params + '$1');
        },
        
        insert: function(node, flash) {
          node.innerHTML = flash;
        }
      },

      other: {
        object: function(fixFocus, id, src, width, height) {
          var obj   = dom.create('object');
          var attrs = ['type', 'application/x-shockwave-flash', 'id', id, 'name', id, 'data', src, 
                        'width', width, 'height', height];
          while(attrs.length) obj.setAttribute(attrs.shift(), attrs.shift());
          obj.className = CSS_FLASH;
          
          if(!fixFocus) return obj;
          
          var node = dom.create("div");
          node.className = CSS_FIX_FOCUS;
          node.appendChild(obj);
          return node;
        },

        params: function(obj) {
          for(var i = 1; i < arguments.length; i+=2) {
            if (arguments[i] == 'name') continue;
            var param = dom.create('param');
            param.setAttribute('name', arguments[i]);
            param.setAttribute('value', arguments[i + 1]);
            obj.appendChild(param);
          }
          return obj;
        },
        
        insert: function(node, flash) {
          while (node.firstChild) node.removeChild(node.firstChild);
          node.appendChild(flash);
        }
      }
    };
  };
  this.dom = dom;

  var ua = new function() {
    var ua                = navigator.userAgent.toLowerCase();
    var product           = (navigator.product || '').toLowerCase();

    this.macintosh        = ua.indexOf('mac') > -1;
    this.windows          = ua.indexOf('windows') > -1;
    this.quicktime        = false;

    this.opera            = ua.indexOf('opera') > -1;
    this.konqueror        = product.indexOf('konqueror') > -1;
    this.ie               = false/*@cc_on || true @*/;
    this.ieSupported      = this.ie && !/ppc|smartphone|iemobile|msie\s5\.5/.test(ua)/*@cc_on && @_jscript_version >= 5.5 @*/
    this.ieWin            = this.ie && this.windows/*@cc_on && @_jscript_version >= 5.1 @*/;
    this.windows          = this.windows && (!this.ie || this.ieWin);
    this.ieMac            = this.ie && this.macintosh/*@cc_on && @_jscript_version < 5.1 @*/;
    this.macintosh        = this.macintosh && (!this.ie || this.ieMac);
    this.safari           = ua.indexOf('safari') > -1;
    this.webkit           = ua.indexOf('applewebkit') > -1 && !this.konqueror;
    this.khtml            = this.webkit || this.konqueror;
    this.gecko            = !this.webkit && product == 'gecko';

    this.ieVersion        = this.ie        && /.*msie\s(\d\.\d)/.exec(ua)         ? parseFloat(RegExp.$1) : 0;
    this.operaVersion     = this.opera     && /.*opera(\s|\/)(\d+\.\d+)/.exec(ua) ? parseFloat(RegExp.$2) : 0;
    this.webkitVersion    = this.webkit    && /.*applewebkit\/(\d+).*/.exec(ua)   ? parseFloat(RegExp.$1) : 0;
    this.geckoBuildDate   = this.gecko     && /.*gecko\/(\d{8}).*/.exec(ua)       ? parseFloat(RegExp.$1) : 0;
    this.konquerorMajor   = this.konqueror && /.*konqueror\/(\d).*/.exec(ua)      ? parseFloat(RegExp.$1) : 0;
    this.konquerorMinor   = this.konqueror && /.*khtml\/\d\.(\d).*/.exec(ua)      ? parseFloat(RegExp.$1) : 0;
    this.konquerorSmall   = this.konqueror && /.*khtml\/\d\.\d\.(\d).*/.exec(ua)  ? parseFloat(RegExp.$1) : 0;
    
    this.flashVersion     = 0;
    if(this.ieWin) {
      var axo;
      var stop = false;
      try {
        axo = new ActiveXObject('ShockwaveFlash.ShockwaveFlash.7');
      } catch(e) {
        // In case the Flash 7 registry key does not exist, we need to test for specific 
        // Flash 6 installs before we can use the general key. 
        // See also <http://blog.deconcept.com/2006/01/11/getvariable-setvariable-crash-internet-explorer-flash-6/>.
        try {
          axo                   = new ActiveXObject('ShockwaveFlash.ShockwaveFlash.6');
          this.flashVersion     = 6;
          axo.AllowScriptAccess = 'always';
        } catch(e) { stop = this.flashVersion == 6; }

        if(!stop) try { axo = new ActiveXObject('ShockwaveFlash.ShockwaveFlash'); } catch(e) {}
      }

      if(!stop && axo) this.flashVersion = parseFloat(/([\d,?]+)/.exec(axo.GetVariable('$version'))[1].replace(/,/g, '.'));
    } else if(navigator.plugins && navigator.plugins['Shockwave Flash']) {
      var flashPlugin = navigator.plugins['Shockwave Flash'];
      this.flashVersion = parseFloat(/(\d+\.?\d*)/.exec(flashPlugin.description)[1]);

      // Watch out for QuickTime, which could be stealing the Flash handling!
      var i = 0;
      while(this.flashVersion >= MIN_FLASH_VERSION && i < navigator.mimeTypes.length) {
        var mime = navigator.mimeTypes[i];
        if(mime.type == 'application/x-shockwave-flash' && mime.enabledPlugin.description.toLowerCase().indexOf('quicktime') > -1) {
          this.flashVersion = 0;
          this.quicktime = true;
        }
        i++;
      }
    }

    this.flash = this.flashVersion >= MIN_FLASH_VERSION;

    // There are other conditions, but these are ruled out in `computedStyledSupport` or `supported`.
    this.transparencySupport  = this.macintosh || this.windows;

    this.computedStyleSupport = this.ie || document.defaultView && document.defaultView.getComputedStyle 
      && (!this.gecko || this.geckoBuildDate >= 20030624); // Older Geckos have trouble with `getComputedStyle()`
    
    this.requiresPrefetch  = this.ieWin || this.khtml;
    this.fixFocus          = this.gecko && this.windows && this.geckoBuildDate > 20061206;
    this.nativeDomLoaded   = this.gecko || this.webkit && this.webkitVersion >= 525 
                                        || this.konqueror && this.konquerorMajor > 3 || this.opera;
    this.mustCheckStyle    = this.khtml || this.opera;
    this.forcePageLoad     = this.webkit && this.webkit < 523; // Fine in Konqueror 3.5.8, which is required for support.
    this.properDocument    = typeof(document.location) == 'object';

    this.supported         = this.flash && this.properDocument && (!this.ie || this.ieSupported) 
      && (!this.opera/* || this.operaVersion >= 8*/) && (!this.webkit || this.webkitVersion >= 412)
      && (!this.konqueror/* || this.konquerorMajor > 3 || this.konquerorMajor == 3 && (this.konquerorMinor > 5 || this.konquerorMinor == 5 & this.konquerorSmall > 7)*/)
      && this.computedStyleSupport
      && (!this.gecko || this.geckoBuildDate > 20040804); 

  };
  this.ua = ua;

  var util = new function() {
    var UNIT_REMOVAL_PROPERTIES = {leading: true, 'margin-left': true, 'margin-right': true, 'text-indent': true};
    var SINGLE_WHITESPACE = ' ';
    
    function capitalize($) {
      return $.toUpperCase();
    }
    
    this.normalize = function(str) {
      if(SIFR.preserveSingleWhitespace) return str.replace(/\s/g, SINGLE_WHITESPACE);
      // Replace linebreaks by whitespace, then normalize and make sure no nbsp characters are 
      // preserved as Flash doesn't seem to support them.
      return str.replace(/(\n|\r)+/g, SINGLE_WHITESPACE).replace(/(\s)\s+/g, '$1').replace(/\xA0/, SINGLE_WHITESPACE);
    };
    
    this.textTransform = function(type, str) {
      switch(type) {
        case 'uppercase':
          str = str.toUpperCase();
          break;
        
        case 'lowercase':
          str = str.toLowerCase();
          break;
          
        case 'capitalize':
          var strCopy = str;
          str = str.replace(/^\w|\s\w/g, capitalize);
          if(str.indexOf('function capitalize') != -1) {
            var substrs = strCopy.replace(/(^|\s)(\w)/g, '$1$1$2$2').split(/^\w|\s\w/g);
            str = '';
            for(var i = 0; i < substrs.length; i++) str += substrs[i].charAt(0).toUpperCase() + substrs[i].substring(1);
          }
          break;
      }
      
      return str;
    };
    
    this.toHexString = function(str) {
      if(typeof(str) != 'string' || !str.charAt(0) == '#' || str.length != 4 && str.length != 7) return str;
      
      str = str.replace(/#/, '');
      if(str.length == 3) str = str.replace(/(.)(.)(.)/, '$1$1$2$2$3$3');

      return '0x' + str;
    };

    this.toJson = function(obj) {
      var json = '';

      switch(typeof(obj)) {
        case 'string':
          json = '"' + obj + '"';
          break;
        case 'number':
        case 'boolean':
          json = obj.toString();
          break;
        case 'object':
          json = [];
          for(var prop in obj) {
            if(obj[prop] == Object.prototype[prop]) continue;
            json.push('"' + prop + '":' + util.toJson(obj[prop]));
          }
          json = '{' + json.join(',') + '}';
          break;
      }

      return json;
    };
    
    this.convertCssArg = function(arg) {
      if(!arg) return {};
      if(typeof(arg) == 'object') {
        if(arg.constructor == Array) arg = arg.join('');
        else return arg;
      }

      var obj = {};
      var rules = arg.split('}');

      for(var i = 0; i < rules.length; i++) {
        var $ = rules[i].match(/([^\s{]+)\s*\{(.+)\s*;?\s*/);
        if(!$ || $.length != 3) continue;

        if(!obj[$[1]]) obj[$[1]] = {};

        var properties = $[2].split(';');
        for(var j = 0; j < properties.length; j++) {
          var $2 = properties[j].match(/\s*([^:\s]+)\s*\:\s*([^;]+)/);
          if(!$2 || $2.length != 3) continue;
          obj[$[1]][$2[1]] = $2[2].replace(/\s+$/, '');
        }
      }

      return obj;
    };

    this.extractFromCss = function(css, selector, property, remove) {
      var value = null;

      if(css && css[selector] && css[selector][property]) {
        value = css[selector][property];
        if(remove) delete css[selector][property];
      }

      return value;
    };
    
    this.cssToString = function(arg) {
      var css = [];
      for(var selector in arg) {
        var rule = arg[selector];
        if(rule == Object.prototype[selector]) continue;

        css.push(selector, '{');
        for(var property in rule) {
          if(rule[property] == Object.prototype[property]) continue;
          var value = rule[property];
          if(UNIT_REMOVAL_PROPERTIES[property]) value = parseInt(value, 10);
          css.push(property, ':', value, ';');
        }
        css.push('}');
      }

      return css.join('');
    };

    this.bind = function(scope, method) {
      return function() {
        scope[method].apply(scope, arguments);
      };
    };

    this.escape = function(str) {
      return escape(str).replace(/\+/g, '%2B');
    };
    
    this.copyProperties = function(from, to) {
      for(var property in from) {
        if(to[property] === undefined) to[property] = from[property];
      }
      return to;
    };
    
    this.domain = function() {
      var domain = '';
      try { // When trying to access document.domain on a Google-translated page with Firebug, I got an exception.
        domain = document.domain;
      } catch(e) {};
      return domain;
    };
    
    this.domainMatches = function(domain, match) {
      if(match == '*' || match == domain) return true;

      var wildcard = match.lastIndexOf('*');
      if(wildcard > -1) {
        match = match.substr(wildcard + 1);
        var matchPosition = domain.lastIndexOf(match);
        if(matchPosition > -1 && (matchPosition + match.length) == domain.length) return true;
      }
      
      return false;
    };
    
    this.uriEncode = function(s) {
      return encodeURI(decodeURIComponent(s));  // Decode first, in case the URI was already encoded.
    }
  };
  this.util = util;

  var hacks = {};
  hacks.fragmentIdentifier = new function() {
    this.fix = true;

    var cachedTitle;
    this.cache = function() {
      cachedTitle = document.title;
    };

    function doFix() {
      document.title = cachedTitle;
    }

    this.restore = function() {
      if(this.fix) setTimeout(doFix, 0);
    };
  };
  this.hacks = {fragmentIdentifier: hacks.fragmentIdentifier};

  hacks.pageLoad = new function() {
    var dummy = null;
    
    function pollLoad() {
      try {
        // IE hack courtesy of Diego Perini – <http://javascript.nwbox.com/IEContentLoaded/>.
        // Merged polling taken from jQuery – <http://dev.jquery.com/browser/trunk/jquery/src/event.js>
        if(ua.ie || document.readyState != 'loaded' && document.readyState != 'complete') {
          document.documentElement.doScroll('left');
        }
      } catch(e) {
        return setTimeout(pollLoad, 10);
      }
      afterDomLoad();
    };
    
    function afterDomLoad() {
      if(SIFR.useStyleCheck) checkStyle();
      else if(!ua.mustCheckStyle) fire(null, true);
    };
    
    function checkStyle() {
      dummy           = dom.create("div");
      dummy.className = CSS_DUMMY;
      dom.getBody().appendChild(dummy);
      pollStyle();
    };
    
    function pollStyle() {
      if(dom.getComputedStyle(dummy, 'marginLeft') == '42px') afterStyle();
      else setTimeout(pollStyle, 10);
    };
    
    function afterStyle() {
      if(dummy && dummy.parentNode) dummy.parentNode.removeChild(dummy);
      dummy = null;
      fire(null, true);
    };
    
    function fire(evt, preserveReplacements) {
      SIFR.initialize(preserveReplacements);

      // Remove handlers to prevent memory leak in Firefox 1.5, but only after onload.
      if(evt && evt.type == 'load') {
        if(document.removeEventListener) document.removeEventListener('DOMContentLoaded', fire, false);
        if(window.removeEventListener) window.removeEventListener('load', fire, false);
      }
    };
    
    this.attach = function() {
      if(window.addEventListener) window.addEventListener('load', fire, false);
      else window.attachEvent('onload', fire);

      if(!SIFR.useDomLoaded || ua.forcePageLoad || ua.ie && window.top != window) return;
      
      if(ua.nativeDomLoaded) {
        document.addEventListener('DOMContentLoaded', afterDomLoad, false);
      } else if(ua.ie || ua.khtml) {
        pollLoad();
      } 
    };
  };

  hacks.zoom = new function() {
    var element, lastOffset;
    
    function detect() {
      if(element.offsetLeft != lastOffset) {
        lastOffset = element.offsetLeft;
        resize(null, true);
      }
    }
    
    this.init = function() {
      if(!ua.ie || ua.ieVersion < 7) return;

      element = dom.create('div');
      element.className = CSS_ZOOM_DETECT;
      element.style.cssText = 'display:block;width:auto;position:absolute;left:10%;top:-100px;';
      dom.getBody().appendChild(element);
      lastOffset = element.offsetLeft;
      setInterval(detect, 200);
    };
  };

  this.errors = {
    fire: function(id) {
      if(this[id + 'Alert']) alert(this[id + 'Alert']);
      throw new Error(this[id]);
    },
    isFile:      'sIFR: Did not activate because the page is being loaded from the filesystem.',
    isFileAlert: 'Hi!\n\nThanks for using sIFR on your page. Unfortunately sIFR couldn\'t activate, because it was loaded '
                  + 'directly from your computer.\nDue to Flash security restrictions, you need to load sIFR through a web'
                  + ' server.\n\nWe apologize for the inconvenience.',
    getSource:   'sIFR: Could not determine appropriate source'
  };

  var replaceKwargsStore = {
    kwargs: [],
    replaceAll:  function(preserve) {
      for(var i = 0; i < this.kwargs.length; i++) SIFR.replace(this.kwargs[i]);
      if(!preserve) this.kwargs = [];
    }
  };

  // The goal here is not to prevent usage of the Flash movie, but running sIFR on possibly translated pages
  function isValidDomain() {
    if(SIFR.domains.length == 0) return true;

    var domain = util.domain();

    for(var i = 0; i < SIFR.domains.length; i++) {
      var match = SIFR.domains[i];
      if(util.domainMatches(domain, match)) return true;
    }

    return false;
  }

  function isFile() {
    if(!SIFR.fromLocal && document.location.protocol == 'file:') {
      if(SIFR.debug) SIFR.errors.fire('isFile');
      return true;
    }
    return false;
  }

  function resize(evt, force) {
    var viewport = force ? {} : resize.viewport;
    resize.viewport = {
      width: window.innerWidth || document.documentElement.clientWidth || dom.getBody().clientWidth,
      height: window.innerHeight || document.documentElement.clientHeight || dom.getBody().clientHeight
    };

    if(viewport && resize.viewport.width == viewport.width && resize.viewport.height == viewport.height) {
      return;
    }

    if(resize.timer) clearTimeout(resize.timer);
    resize.timer = setTimeout(function() {
      delete resize.timer;
      for(var i = 0; i < SIFR.callbacks.length; i++) SIFR.callbacks[i].resize();
    }, 200);
  }

  function scale() {
    for(var i = 0; i < SIFR.callbacks.length; i++) SIFR.callbacks[i].call('scale');
  }

  this.activate = function(/* … */) {
    if(!ua.supported || !this.isEnabled || this.isActive || !isValidDomain() || isFile()) return;
    if(arguments.length > 0) this.prefetch.apply(this, arguments);

    this.isActive = true;
    this.setFlashClass();

    hacks.fragmentIdentifier.fix = ua.ieWin && hacks.fragmentIdentifier.fix && window.location.hash != ''
    if(hacks.fragmentIdentifier.fix) hacks.fragmentIdentifier.cache();

    if(!this.autoInitialize) return;
    
    hacks.pageLoad.attach();

    if(ua.ie) {
      window.attachEvent('onunload', function() {
        dom.addClass(CSS_UNLOADING, document.documentElement);
      });
    }
  };

  this.setFlashClass = function() {
    if(this.hasFlashClassSet) return;

    dom.addClass(CSS_ACTIVE, dom.getBody() || document.documentElement);
    this.hasFlashClassSet = true;
  };

  this.removeFlashClass = function() {
    if(!this.hasFlashClassSet) return;

    dom.removeClass(CSS_ACTIVE, dom.getBody());
    dom.removeClass(CSS_ACTIVE, document.documentElement);
    this.hasFlashClassSet = false;
  }

  this.initialize = function(preserveReplacements) {
    if(!this.isActive || !this.isEnabled) return;
    if(isInitialized) {
      if(!preserveReplacements) replaceKwargsStore.replaceAll(false);
      return;
    }

    isInitialized = true;
    replaceKwargsStore.replaceAll(preserveReplacements);
    if(SIFR.repaintOnResize) {
      if(window.addEventListener) {
        window.addEventListener('resize', resize, false);
        window.addEventListener('scroll', scale, false);
      } else {
        window.attachEvent('onresize', resize);
        window.attachEvent('onscroll', scale);
      }
      
      hacks.zoom.init();
    }
    clearPrefetch();
  };

  function getSource(src) {
    if(typeof(src) != 'string') {
      if(src.src) src = src.src;

      // It might be a string now...
      if(typeof(src) != 'string') {
        var versions = [];
        for(var version in src) if(src[version] != Object.prototype[version]) versions.push(version);
        versions.sort().reverse();

        var result = '';
        var i = -1;
        while(!result && ++i < versions.length) {
          if(parseFloat(versions[i]) <= ua.flashVersion) result = src[versions[i]];
        }
        
        src = result;
      }
    }
    
    if(!src && SIFR.debug) SIFR.errors.fire('getSource');
    
    // Some IE installs refuse to show the Flash unless it gets the really absolute
    // URI of the file. I haven't been able to reproduce this behavior but let's
    // ensure a full URI none the less. This turns `/foo.swf` in `http://example.com/foo.swf`.
    if(ua.ie && src.charAt(0) == '/') {
      src = window.location.toString().replace(/([^:]+)(:\/?\/?)([^\/]+).*/, '$1$2$3') + src;
    }
    
    return src;
  }

  this.prefetch = function(/* … */) {
    if((!ua.requiresPrefetch && !this.isActive) || !ua.supported || !this.isEnabled || !isValidDomain()) return;
    if(this.setPrefetchCookie && new RegExp(';?' + PREFETCH_COOKIE + '=true;?').test(document.cookie)) return;

    try { // We don't know which DOM actions the user agent will allow
      hasPrefetched = true;

      if(ua.ieWin) prefetchIexplore(arguments);
      else prefetchLight(arguments);

      if(this.setPrefetchCookie) document.cookie = PREFETCH_COOKIE + '=true;path=' + this.cookiePath;
    } catch(e) { if(SIFR.debug) throw e; }
  };

  function prefetchIexplore(args) {
    for(var i = 0; i < args.length; i++) {
      document.write('<script defer type="sifr/prefetch" src="' + getSource(args[i]) + '"></script>');
    }
  }

  function prefetchLight(args) {
    for(var i = 0; i < args.length; i++) new Image().src = getSource(args[i]);
  }

  function clearPrefetch() {
    if(!ua.ieWin || !hasPrefetched) return;

    try {
      var nodes = document.getElementsByTagName('script');
      for(var i = nodes.length - 1; i >= 0; i--) {
        var node = nodes[i];
        if(node.type == 'sifr/prefetch') node.parentNode.removeChild(node);
      }
    } catch(e) {}
  }

  // Gives a font-size to required vertical space ratio
  function getRatio(size, ratios) {
    for(var i = 0; i < ratios.length; i += 2) {
      if(size <= ratios[i]) return ratios[i + 1];
    }
    return ratios[ratios.length - 1] || 1;
  }

  function getFilters(obj) {
    var filters = [];
    for(var filter in obj) {
      if(obj[filter] == Object.prototype[filter]) continue;

      var properties = obj[filter];
      filter = [filter.replace(/filter/i, '') + 'Filter'];

      for(var property in properties) {
        if(properties[property] == Object.prototype[property]) continue;
        filter.push(property + ':' + util.escape(util.toJson(util.toHexString(properties[property]))));
      }

      filters.push(filter.join(','));
    }

    return util.escape(filters.join(';'));
  }
  
  function calculate(node) {
    var lineHeight, lines;
    if(!ua.ie) { //:=todo Only do once for each selector?
      lineHeight = dom.getStyleAsInt(node, 'lineHeight');
      lines = Math.floor(dom.getStyleAsInt(node, 'height') / lineHeight);
    } else if(ua.ie) {
      // IE returs computed style in the original units, which is quite useless.
      // Therefore we'll only use the fontSize if it's in pixel units, otherwise we'll approximate.
      var fontSize = dom.getComputedStyle(node, 'fontSize');
      if(fontSize.indexOf('px') > 0) {
        lineHeight = parseInt(fontSize);
      } else {
        var html = node.innerHTML;

        // Without these settings, we won't be able to get the rects properly. getClientRects()
        // won't work on elements having layout or that are hidden.
        node.style.visibility  = 'visible';
        node.style.overflow    = 'visible';
        node.style.position    = 'static';
        node.style.zoom        = 'normal';
        node.style.writingMode = 'lr-tb';
        node.style.width       = node.style.height = 'auto';
        node.style.maxWidth    = node.style.maxHeight = node.style.styleFloat  = 'none';
      
        var rectNode = node;
        var hasLayout = node.currentStyle.hasLayout;
        if(hasLayout) {
          node.innerHTML = '<div class="' + CSS_LAYOUT + '">X<br />X<br />X</div>';
          rectNode = node.firstChild;
        } else node.innerHTML = 'X<br />X<br />X';

        var rects = rectNode.getClientRects();
        lineHeight = rects[1].bottom - rects[1].top;

        // In IE, the lineHeight is about 1.25 times the height in other browsers.
        lineHeight = Math.ceil(lineHeight * 0.8);

        if(hasLayout) {
          node.innerHTML = '<div class="' + CSS_LAYOUT + '">' + html + '</div>';
          rectNode = node.firstChild;
        } else node.innerHTML = html;
        rects = rectNode.getClientRects();
        lines = rects.length;

        if(hasLayout) node.innerHTML = html;

        node.style.visibility = node.style.width = node.style.height = node.style.maxWidth 
                              = node.style.maxHeight = node.style.overflow = node.style.styleFloat
                              = node.style.position = node.style.zoom = node.style.writingMode 
                              = '';
      }
    }
    
    return {lineHeight: lineHeight, lines: lines};
  }
  
  this.replace = function(kwargs, mergeKwargs) {
    if(!ua.supported) return;
    

    if(mergeKwargs) kwargs = util.copyProperties(kwargs, mergeKwargs);

    if(!isInitialized) return replaceKwargsStore.kwargs.push(kwargs);
    
    if(SIFR.onReplacementStart) SIFR.onReplacementStart(kwargs);

    var nodes = kwargs.elements;
    if(!nodes && parseSelector) nodes = parseSelector(kwargs.selector);
    if(nodes.length == 0) return;

    var src = getSource(kwargs.src);
    var css = util.convertCssArg(kwargs.css);
    var filters = getFilters(kwargs.filters);
    
    var forceClear      = (kwargs.forceClear == null) ? SIFR.forceClear : kwargs.forceClear;
    var fitExactly      = (kwargs.fitExactly == null) ? SIFR.fitExactly : kwargs.fitExactly;
    var forceWidth      = fitExactly || (kwargs.forceWidth == null ? SIFR.forceWidth : kwargs.forceWidth);
    var preventWrap     = !!(kwargs.preventWrap && !kwargs.forceSingleLine);

    var leading         = parseInt(util.extractFromCss(css, '.sIFR-root', 'leading')) || 0;
    var fontSize        = util.extractFromCss(css, '.sIFR-root', 'font-size', true) || 0;
    var backgroundColor = util.extractFromCss(css, '.sIFR-root', 'background-color', true) || '#FFFFFF';
    var kerning         = util.extractFromCss(css, '.sIFR-root', 'kerning', true) || '';
    var gridFitType     = kwargs.gridFitType || util.extractFromCss(css, '.sIFR-root', 'text-align') == 'right' ? 'subpixel' : 'pixel';
    var textTransform   = SIFR.forceTextTransform ? util.extractFromCss(css, '.sIFR-root', 'text-transform', true) || 'none' : 'none';
    var opacity         = util.extractFromCss(css, '.sIFR-root', 'opacity', true) || '100';
    var cursor          = util.extractFromCss(css, '.sIFR-root', 'cursor', true) || 'default';
    var pixelFont       = kwargs.pixelFont || false;
    var ratios          = kwargs.ratios || DEFAULT_RATIOS;
    var tuneHeight      = parseInt(kwargs.tuneHeight) || 0;
    var events          = !!kwargs.onRelease || !!kwargs.onRollOver || !!kwargs.onRollOut;

    if(parseInt(fontSize).toString() != fontSize && fontSize.indexOf('px') == -1) fontSize = 0; // We only support pixel sizes
    else fontSize = parseInt(fontSize);
    if(parseFloat(opacity) < 1) opacity = 100 * parseFloat(opacity); // Make sure to support percentages and decimals

    var cssText = '';
    // Alignment is handled by the browser in this case.
    if(fitExactly) util.extractFromCss(css, '.sIFR-root', 'text-align', true);
    if(!kwargs.modifyCss) cssText = util.cssToString(css);

    var wmode = kwargs.wmode || '';
    if(!wmode) {
      if(kwargs.transparent) wmode = 'transparent';
      else if(kwargs.opaque) wmode = 'opaque';
    } 
    if(wmode == 'transparent') {
      if(!ua.transparencySupport) wmode = 'opaque';
      else backgroundColor = 'transparent';
    }

    for(var i = 0; i < nodes.length; i++) {
      var node = nodes[i];

      if(dom.hasOneOfClassses([CSS_REPLACED, CSS_IGNORE, CSS_ALTERNATE], node)) continue;

      var dimensions = dom.getDimensions(node);
      var height     = dimensions.height;
      var width      = dimensions.width;
      var display    = dom.getComputedStyle(node, 'display');

      if(!height || !width || display == null || display == 'none') continue;

      if(forceClear && ua.gecko) node.style.clear = 'both';

      var html = null;
      if(SIFR.fixWrap && ua.ie && display == 'block') {
        html = node.innerHTML;
        node.innerHTML = 'X';
      }

      width = dom.getWidthFromStyle(node);

      if(html && SIFR.fixWrap && ua.ie) node.innerHTML = html;

      var lineHeight, lines;
      if(!fontSize) {
        var calculation = calculate(node);
        lineHeight      = Math.min(MAX_FONT_SIZE, Math.max(MIN_FONT_SIZE, calculation.lineHeight));
        if(pixelFont) lineHeight = Math.max(8, 8 * Math.round(lineHeight / 8));

        lines = calculation.lines;
        if(isNaN(lines) || !isFinite(lines) || lines == 0) lines = 1;

        if(lines > 1 && leading) height += Math.round((lines - 1) * leading);
      } else {
        lineHeight = fontSize;
        lines      = 1;
      }

      height = Math.round(lines * lineHeight);

      if(forceClear && ua.gecko) node.style.clear = '';

      var alternate = dom.create('span');
      alternate.className = CSS_ALTERNATE;

      var contentNode = node.cloneNode(true);
      node.parentNode.appendChild(contentNode);

      for(var j = 0, l = contentNode.childNodes.length; j < l; j++) {
        alternate.appendChild(contentNode.childNodes[j].cloneNode(true));
      }

      if(kwargs.modifyContent) kwargs.modifyContent(contentNode, kwargs.selector);
      if(kwargs.modifyCss) cssText = kwargs.modifyCss(css, contentNode, kwargs.selector);

      var fixHover = SIFR.fixHover && dom.contentIsLink(contentNode);
      var content = handleContent(contentNode, textTransform, kwargs.uriEncode);

      contentNode.parentNode.removeChild(contentNode);

      if(kwargs.modifyContentString) content.text = kwargs.modifyContentString(content.text, kwargs.selector);
      if(content.text == '') continue;
      
      var renderHeight = Math.round(lines * getRatio(lineHeight, ratios) * lineHeight) + FLASH_PADDING_BOTTOM + tuneHeight;
      var forcedWidth = forceWidth ? width : '100%';
      
      var vars = ['content=' + util.escape(content.text), 'antialiastype=' + (kwargs.antiAliasType || ''),
                  'width=' + width, 'height=' + height, 'renderheight=' + renderHeight, 'fitexactly=' + fitExactly,
                  'tunewidth=' + (kwargs.tuneWidth || 0), 'tuneheight=' + tuneHeight,
                  'offsetleft=' + (kwargs.offsetLeft || ''), 'offsettop=' + (kwargs.offsetTop || ''),
                  'thickness=' + (kwargs.thickness || ''), 'sharpness=' + (kwargs.sharpness || ''),
                  'kerning=' + kerning, 'gridfittype=' + gridFitType, 'flashfilters=' + filters,
                  'opacity=' + opacity, 'blendmode=' + (kwargs.blendMode || ''), 'size=' + lineHeight,
                  'css=' + util.escape(cssText), 'selectable=' + (kwargs.selectable == null ? 'true' : kwargs.selectable),
                  'fixhover=' + fixHover, 'preventwrap=' + preventWrap, 'forcesingleline=' + (kwargs.forceSingleLine === true),
                  'link=' + util.escape(content.primaryLink[0] || ''), 'target=' + util.escape(content.primaryLink[1] || ''),
                  'events=' + events, 'cursor=' + cursor, 'version=' + VERSION];
      var encodedVars = encodeVars(vars);

      var callbackName = 'sIFR_callback_' + elementCount++;
      var callbackInfo = new CallbackInfo(callbackName, vars, forceWidth, {
        onReplacement: kwargs.onReplacement,
        onRollOver: kwargs.onRollOver,
        onRollOut: kwargs.onRollOut,
        onRelease: kwargs.onRelease
      });
      window[callbackName + '_DoFSCommand'] = (function(callbackInfo) {
        return function(info, arg) {
          callbackInfo.handle(info, arg);
        }
      })(callbackInfo);
      alternate.setAttribute('id', callbackName + '_alternate');

      var builder = ua.ie ? dom.swf.ie : dom.swf.other;
      var flash = dom.swf.create(builder, ua.fixFocus && kwargs.fixFocus, callbackName, 
                                  forcedWidth, renderHeight, src, encodedVars, wmode, backgroundColor);
      builder.insert(node, flash);

      callbackInfo.html = flash;
      SIFR.callbacks.push(callbackInfo);
      if(kwargs.selector) {
        if(!SIFR.callbacks[kwargs.selector]) SIFR.callbacks[kwargs.selector] = [callbackInfo];
        else SIFR.callbacks[kwargs.selector].push(callbackInfo);
      }
      node.appendChild(alternate);
      dom.addClass(CSS_REPLACED, node);
    }

    hacks.fragmentIdentifier.restore();
  };

  this.getCallbackByFlashElement = function(node) {
    for(var i = 0; i < SIFR.callbacks.length; i++) {
      if(SIFR.callbacks[i].id == node.getAttribute('id')) return SIFR.callbacks[i];
    }
  };
  
  this.redraw = function() {
    for(var i = 0; i < SIFR.callbacks.length; i++) SIFR.callbacks[i].resetMovie();
  };
  
  function encodeVars(vars) {
    return vars.join('&').replace(/%/g, '%25');
  }

  /* Walks through the childNodes of `source`. Generates a text representation of these childNodes. */
  function handleContent(source, textTransform, uriEncode) {
    uriEncode = uriEncode || util.uriEncode;
    var stack = [], content = [], primaryLink = [];
    var nodes = source.childNodes;

    var i = 0;
    while(i < nodes.length) {
      var node = nodes[i];

      if(node.nodeType == 3) {
        var text = util.normalize(node.nodeValue);
        text = util.textTransform(textTransform, text);
        // Escape < characters because they'll mess with the HTML rendering inside Flash.
        text = text.replace(/</g, '&lt;');
        content.push(text);
      }

      if(node.nodeType == 1) {
        var attributes = [];
        var nodeName = node.nodeName.toLowerCase();

        var className = node.className || '';
        // If there are multiple classes, look for the specified sIFR class
        if(/\s+/.test(className)) {
          if(className.indexOf(CSS_CLASS) > -1) className = className.match('(\\s|^)' + CSS_CLASS + '-([^\\s$]*)(\\s|$)')[2];
          // or use the first class
          else className = className.match(/^([^\s]+)/)[1];
        }
        if(className != '') attributes.push('class="' + className + '"');

        if(nodeName == 'a') {
          var href = uriEncode(node.getAttribute('href') || '');
          var target = node.getAttribute('target') || '';
          attributes.push('href="' + href + '"', 'target="' + target + '"');
          
          if(primaryLink.length == 0) primaryLink = [href, target];
        }

        content.push('<' + nodeName + (attributes.length > 0 ? ' ' : '') + attributes.join(' ') + '>');

        if(node.hasChildNodes()) {
          stack.push(i);
          i = 0;
          nodes = node.childNodes;
          continue;
        } else if(!/^(br|img)$/i.test(node.nodeName)) content.push('</', node.nodeName.toLowerCase(), '>');
      }

      if(stack.length > 0 && !node.nextSibling) {

        do {
          i = stack.pop();
          nodes = node.parentNode.parentNode.childNodes;
          node = nodes[i];
          if(node) content.push('</', node.nodeName.toLowerCase(), '>');
        } while(i == nodes.length - 1 && stack.length > 0);
      }

      i++;
    }
  
    return {text: content.join('').replace(/\n|\r/g, ''), primaryLink: primaryLink};
  }

  function CallbackInfo(id, vars, forceWidth, events) {
    this.id                     = id;
    this.vars                   = vars;
    this._events                = events;
    this._forceWidth            = forceWidth;
    this._firedReplacementEvent = !(events.onReplacement != null);
    // Type of value depends on SWF builder. This could use some improvement!
    this.html                   = null;
  }
  
  CallbackInfo.prototype.getFlashElement = function() {
    return document.getElementById(this.id);
  };

  CallbackInfo.prototype.available = function() {
    var flashNode = this.getFlashElement();
    return flashNode && flashNode.parentNode;
  };

  CallbackInfo.prototype.handle = function(info, arg) {
    if(!this.available()) return;
    
    switch(/(FSCommand\:)?(.+)/.exec(info)[2]) {
      case 'resize':
        var flashNode = this.getFlashElement();
        
        var $ = arg.split(/\:|,/);
        flashNode.setAttribute($[0], $[1]);
        if($.length > 2) flashNode.style[$[2]] = $[3] + 'px';
      
        if(ua.khtml) var repaint = flashNode.offsetHeight;
      
        if(!this._firedReplacementEvent) {
          this._events.onReplacement(this);
          this._firedReplacementEvent = true;
        }
        break;
      case 'resetmovie':
        this.resetMovie();
        break;
      case 'blur':
        dom.blurElement(this.getFlashElement());
        break;
      case 'event':
        if(this._events[arg]) this._events[arg](this);
        break;
      default:
        if(this.debugHandler && /(FSCommand\:)?debug/.test(info)) this.debugHandler(info, arg);
    }
  };
  
  CallbackInfo.prototype.call = function(type, value) {
    if(!this.available()) return false;

    var flashNode = this.getFlashElement();
    try {
      flashNode.SetVariable('callbackType', type);
      flashNode.SetVariable('callbackValue', value);
      flashNode.SetVariable('callbackTrigger', true);
    } catch(e) {
      return false;
    }
    
    return true;
  };

  CallbackInfo.prototype.replaceText = function(content, alternate) {
    var escapedContent = util.escape(content);
    this.updateVars('content', escapedContent);
    if(this.call('replacetext', escapedContent)) {
      var node = this.getAlternate();
      if(alternate) {
        while(node.firstChild) node.removeChild(node.firstChild);
        for(var i = 0; i < alternate.length; i++) node.appendChild(alternate[i]);
      } else {
        try { node.innerHTML = content; } catch(e) {};
      }
      return true;
    }
    return false;
  };
  
  CallbackInfo.prototype.updateVars = function(name, value) {
    for(var i = 0; i < this.vars.length; i++) {
      if (this.vars[i].split('=')[0] == name)
      {
        this.vars[i] = name + '=' + value;
        break;
      }
    }
  };
  
  CallbackInfo.prototype.resetMovie = function() {
    if(!this.available()) return;

    var flashNode = this.getFlashElement();
    var node = flashNode.parentNode;

    var vars = encodeVars(this.vars);
    if(ua.ie) {
      this.html = this.html.replace(/(flashvars(=|\"\svalue=)\")[^\"]+/, '$1' + vars);
      node.replaceChild(dom.nodeFromHtml(this.html), flashNode);
    } else {
      var params = this.html.getElementsByTagName('param');
      for(var i = 0; i < params.length; i++) {
        if(params[i].getAttribute('name') == 'flashvars') {
          params[i].setAttribute('value', vars);
          break;
        }
      }
      node.replaceChild(this.html.cloneNode(true), flashNode);
    }
  };

  CallbackInfo.prototype.resize = function() {
    if(!this.available()) return;

    var flashNode      = this.getFlashElement();
    var ancestor       = flashNode.parentNode;
    var currentWidth   = flashNode.offsetWidth;
    var originalWidth  = flashNode.getAttribute('width');
    var originalHeight = flashNode.getAttribute('height');
    
    // Remove Flash movie from flow
    flashNode.style.width = '0px';
    flashNode.style.height = '0px';
    
    // Set a minimal height on the flashNode's parent, to stop a reflow
    flashNode.parentNode.style.minHeight = originalHeight;
    
    // Restore original content
    var nodes = this.getAlternate().childNodes;
    var clones = [];
    for(var i = 0; i < nodes.length; i++) {
      var node = nodes[i].cloneNode(true);
      clones.push(node);
      ancestor.appendChild(node);
    }
    
    // Calculate width
    var width = dom.getWidthFromStyle(ancestor);

    // Remove original content again
    for(var i = 0; i < clones.length; i++) ancestor.removeChild(clones[i]);

    // Reset Flash movie flow
    flashNode.style.width = flashNode.style.height = flashNode.parentNode.style.minHeight = '';
    flashNode.setAttribute('width', this._forceWidth ? width : originalWidth);
    flashNode.setAttribute('height', originalHeight);

    // Resize!
    if(width != currentWidth) this.call('resize', width);
    else this.call('scale');
  };
  
  CallbackInfo.prototype.changeCSS = function(css) {
    css = util.escape(util.cssToString(util.convertCssArg(css)));
    this.updateVars('css', css);
    return this.call('changecss', css);
  };
  
  CallbackInfo.prototype.getAlternate = function() {
    return document.getElementById(this.id + '_alternate');
  };
};