RubyGems - closure - Versions diffs - 1.2.701 → 1.3.0 - Mend

closure 1.2.701 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1566) hide show

data/closure-library/closure/goog/cssom/iframe/style.js DELETED Viewed

@@ -1,1020 +0,0 @@
-// Copyright 2007 The Closure Library Authors. All Rights Reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS-IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// All Rights Reserved.
-/**
- * @fileoverview Provides utility routines for copying modified
- * {@code CSSRule} objects from the parent document into iframes so that any
- * content in the iframe will be styled as if it was inline in the parent
- * document.
- *
- * <p>
- * For example, you might have this CSS rule:
- *
- * #content .highlighted { background-color: yellow; }
- *
- * And this DOM structure:
- *
- * <div id="content">
- *   <iframe />
- * </div>
- *
- * Then inside the iframe you have:
- *
- * <body>
- * <div class="highlighted">
- * </body>
- *
- * If you copied the CSS rule directly into the iframe, it wouldn't match the
- * .highlighted div. So we rewrite the original stylesheets based on the
- * context where the iframe is going to be inserted. In this case the CSS
- * selector would be rewritten to:
- *
- * body .highlighted { background-color: yellow; }
- * </p>
- *
- */
-goog.provide('goog.cssom.iframe.style');
-goog.require('goog.cssom');
-goog.require('goog.dom');
-goog.require('goog.dom.NodeType');
-goog.require('goog.dom.classes');
-goog.require('goog.string');
-goog.require('goog.style');
-goog.require('goog.userAgent');
-/**
- * Regexp that matches "a", "a:link", "a:visited", etc.
- * @type {RegExp}
- * @private
- */
-goog.cssom.iframe.style.selectorPartAnchorRegex_ =
-    /a(:(link|visited|active|hover))?/;
-/**
- * Delimiter between selectors (h1, h2)
- * @type {string}
- * @private
- */
-goog.cssom.iframe.style.SELECTOR_DELIMITER_ = ',';
-/**
- * Delimiter between selector parts (.main h1)
- * @type {string}
- * @private
- */
-goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_ = ' ';
-/**
- * Delimiter marking the start of a css rules section ( h1 { )
- * @type {string}
- * @private
- */
-goog.cssom.iframe.style.DECLARATION_START_DELIMITER_ = '{';
-/**
- * Delimiter marking the end of a css rules section ( } )
- * @type {string}
- * @private
- */
-goog.cssom.iframe.style.DECLARATION_END_DELIMITER_ = '}\n';
-/**
- * Class representing a CSS rule set. A rule set is something like this:
- * h1, h2 { font-family: Arial; color: red; }
- * @constructor
- * @private
- */
-goog.cssom.iframe.style.CssRuleSet_ = function() {
-  /**
-   * Text of the declarations inside the rule set.
-   * For example: 'font-family: Arial; color: red;'
-   * @type {string}
-   */
-  this.declarationText = '';
-  /**
-   * Array of CssSelector objects, one for each selector.
-   * Example: [h1, h2]
-   * @type {Array.<goog.cssom.iframe.style.CssSelector_>}
-   */
-  this.selectors = [];
-};
-/**
- * Initializes the rule set from a {@code CSSRule}.
- *
- * @param {CSSRule} cssRule The {@code CSSRule} to initialize from.
- * @return {boolean} True if initialization succeeded. We only support
- *     {@code CSSStyleRule} and {@code CSSFontFaceRule} objects.
- */
-goog.cssom.iframe.style.CssRuleSet_.prototype.initializeFromCssRule =
-    function(cssRule) {
-  var ruleStyle = cssRule.style; // Cache object for performance.
-  if (!ruleStyle) {
-    return false;
-  }
-  var selector;
-  var declarations;
-  if (ruleStyle &&
-      (selector = cssRule.selectorText) &&
-      (declarations = ruleStyle.cssText)) {
-    // IE get confused about cssText context if a stylesheet uses the
-    // mid-pass hack, and it ends up with an open comment (/*) but no
-    // closing comment. This will effectively comment out large parts
-    // of generated stylesheets later. This errs on the safe side by
-    // always tacking on an empty comment to force comments to be closed
-    // We used to check for a troublesome open comment using a regular
-    // expression, but it's faster not to check and always do this.
-    if (goog.userAgent.IE) {
-      declarations += '/* */';
-    }
-  } else if (cssRule.cssText) {
-    var cssSelectorMatch = /([^\{]+)\{/;
-    var endTagMatch = /\}[^\}]*$/g;
-    // cssRule.cssText contains both selector and declarations:
-    // parse them out.
-    selector = cssSelectorMatch.exec(cssRule.cssText)[1];
-    // Remove selector, {, and trailing }.
-    declarations = cssRule.cssText.replace(cssSelectorMatch, '').replace(
-        endTagMatch, '');
-  }
-  if (selector) {
-    this.setSelectorsFromString(selector);
-    this.declarationText = declarations;
-    return true;
-  }
-  return false;
-};
-/**
- * Parses a selectors string (which may contain multiple comma-delimited
- * selectors) and loads the results into this.selectors.
- * @param {string} selectorsString String containing selectors.
- */
-goog.cssom.iframe.style.CssRuleSet_.prototype.setSelectorsFromString =
-    function(selectorsString) {
-  this.selectors = [];
-  var selectors = selectorsString.split(/,\s*/gm);
-  for (var i = 0; i < selectors.length; i++) {
-    var selector = selectors[i];
-    if (selector.length > 0) {
-      this.selectors.push(new goog.cssom.iframe.style.CssSelector_(selector));
-    }
-  }
-};
-/**
- * Make a copy of this ruleset.
- * @return {goog.cssom.iframe.style.CssRuleSet_} A new CssRuleSet containing
- *     the same data as this one.
- */
-goog.cssom.iframe.style.CssRuleSet_.prototype.clone = function() {
-  var newRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
-  newRuleSet.selectors = this.selectors.concat();
-  newRuleSet.declarationText = this.declarationText;
-  return newRuleSet;
-};
-/**
- * Set the declaration text with properties from a given object.
- * @param {Object} sourceObject Object whose properties and values should
- *     be used to generate the declaration text.
- * @param {boolean=} opt_important Whether !important should be added to each
- *     declaration.
- */
-goog.cssom.iframe.style.CssRuleSet_.prototype.setDeclarationTextFromObject =
-    function(sourceObject, opt_important) {
-  var stringParts = [];
-  // TODO(user): for ... in is costly in IE6 (extra garbage collection).
-  for (var prop in sourceObject) {
-    var value = sourceObject[prop];
-    if (value) {
-      stringParts.push(prop,
-                       ':',
-                       value, (opt_important ? ' !important' : ''),
-                       ';');
-    }
-  }
-  this.declarationText = stringParts.join('');
-};
-/**
- * Serializes this CssRuleSet_ into an array as a series of strings.
- * The array can then be join()-ed to get a string representation
- * of this ruleset.
- * @param {Array.<string>} array The array to which to append strings.
- */
-goog.cssom.iframe.style.CssRuleSet_.prototype.writeToArray = function(array) {
-  var selectorCount = this.selectors.length;
-  var matchesAnchorTag = false;
-  for (var i = 0; i < selectorCount; i++) {
-    var selectorParts = this.selectors[i].parts;
-    var partCount = selectorParts.length;
-    for (var j = 0; j < partCount; j++) {
-      array.push(selectorParts[j].inputString_,
-                 goog.cssom.iframe.style.SELECTOR_PART_DELIMITER_);
-    }
-    if (i < (selectorCount - 1)) {
-      array.push(goog.cssom.iframe.style.SELECTOR_DELIMITER_);
-    }
-    if (goog.userAgent.GECKO && !goog.userAgent.isVersion('1.9a')) {
-      // In Gecko pre-1.9 (Firefox 2 and lower) we need to add !important
-      // to rulesets that match "A" tags, otherwise Gecko's built-in
-      // stylesheet will take precedence when designMode is on.
-      matchesAnchorTag = matchesAnchorTag ||
-          goog.cssom.iframe.style.selectorPartAnchorRegex_.test(
-              selectorParts[partCount - 1].inputString_);
-    }
-  }
-  var declarationText = this.declarationText;
-  if (matchesAnchorTag) {
-    declarationText = goog.cssom.iframe.style.makeColorRuleImportant_(
-        declarationText);
-  }
-  array.push(goog.cssom.iframe.style.DECLARATION_START_DELIMITER_,
-             declarationText,
-             goog.cssom.iframe.style.DECLARATION_END_DELIMITER_);
-};
-/**
- * Regexp that matches "color: value;".
- * @type {RegExp}
- * @private
- */
-goog.cssom.iframe.style.colorImportantReplaceRegex_ =
-    /(^|;|{)\s*color:([^;]+);/g;
-/**
- * Adds !important to a css color: rule
- * @param {string} cssText Text of the CSS rule(s) to modify.
- * @return {string} Text with !important added to the color: rule if found.
- * @private
- */
-goog.cssom.iframe.style.makeColorRuleImportant_ = function(cssText) {
-  // Replace to insert a "! important" string.
-  return cssText.replace(goog.cssom.iframe.style.colorImportantReplaceRegex_,
-                         '$1 color: $2 ! important; ');
-};
-/**
- * Represents a single CSS selector, as described in
- * http://www.w3.org/TR/REC-CSS2/selector.html
- * Currently UNSUPPORTED are the following selector features:
- * <ul>
- *   <li>pseudo-classes (:hover)
- *   <li>child selectors (div > h1)
- *   <li>adjacent sibling selectors (div + h1)
- *   <li>attribute selectors (input[type=submit])
- * </ul>
- * @param {string=} opt_selectorString String containing selectors to parse.
- * @constructor
- * @private
- */
-goog.cssom.iframe.style.CssSelector_ = function(opt_selectorString) {
-  /**
-   * Array of CssSelectorPart objects representing the parts of this selector
-   * Example: for the selector 'body h1' the parts would be [body, h1].
-   * @type {Array.<goog.cssom.iframe.style.CssSelectorPart_>}
-   * @private
-   */
-  this.parts_ = [];
-  /**
-   * Object to track ancestry matches to speed up repeatedly testing this
-   * CssSelector against the same NodeAncestry object.
-   * @type {Object}
-   * @private
-   */
-  this.ancestryMatchCache_ = {};
-  if (opt_selectorString) {
-    this.setPartsFromString_(opt_selectorString);
-  }
-};
-/**
- * Parses a selector string into individual parts.
- * @param {string} selectorString A string containing a CSS selector.
- * @private
- */
-goog.cssom.iframe.style.CssSelector_.prototype.setPartsFromString_ =
-    function(selectorString) {
-  var parts = [];
-  var selectorPartStrings = selectorString.split(/\s+/gm);
-  for (var i = 0; i < selectorPartStrings.length; i++) {
-    if (!selectorPartStrings[i]) {
-      continue; // Skip empty strings.
-    }
-    var part = new goog.cssom.iframe.style.CssSelectorPart_(
-        selectorPartStrings[i]);
-    parts.push(part);
-  }
-  this.parts = parts;
-};
-/**
- * Tests to see what part of a DOM element hierarchy would be matched by
- * this selector, and returns the indexes of the matching element and matching
- * selector part.
- * <p>
- * For example, given this hierarchy:
- *   document > html > body > div.content > div.sidebar > p
- * and this CSS selector:
- *   body div.sidebar h1
- * This would return {elementIndex: 4, selectorPartIndex: 1},
- * indicating that the element at index 4 matched
- * the css selector at index 1.
- * </p>
- * @param {goog.cssom.iframe.style.NodeAncestry_} elementAncestry Object
- *     representing an element and its ancestors.
- * @return {Object} Object with the properties elementIndex and
- *     selectorPartIndex, or null if there was no match.
- */
-goog.cssom.iframe.style.CssSelector_.prototype.matchElementAncestry =
-    function(elementAncestry) {
-  var ancestryUid = elementAncestry.uid;
-  if (this.ancestryMatchCache_[ancestryUid]) {
-    return this.ancestryMatchCache_[ancestryUid];
-  }
-  // Walk through the selector parts and see how far down the element hierarchy
-  // we can go while matching the selector parts.
-  var elementIndex = 0;
-  var match = null;
-  var selectorPart = null;
-  var lastSelectorPart = null;
-  var ancestorNodes = elementAncestry.nodes;
-  var ancestorNodeCount = ancestorNodes.length;
-  for (var i = 0; i <= this.parts.length; i++) {
-    selectorPart = this.parts[i];
-    while (elementIndex < ancestorNodeCount) {
-      var currentElementInfo = ancestorNodes[elementIndex];
-      if (selectorPart &&
-          selectorPart.testElement(currentElementInfo)) {
-        match = {
-          elementIndex: elementIndex,
-          selectorPartIndex: i
-        };
-        elementIndex++;
-        break;
-      } else if (lastSelectorPart &&
-                 lastSelectorPart.testElement(currentElementInfo)) {
-        match = {
-          elementIndex: elementIndex,
-          selectorPartIndex: i - 1
-        };
-      }
-      elementIndex++;
-    }
-    lastSelectorPart = selectorPart;
-  }
-  this.ancestryMatchCache_[ancestryUid] = match;
-  return match;
-};
-/**
- * Represents one part of a CSS Selector. For example in the selector
- * 'body #foo .bar', body, #foo, and .bar would be considered selector parts.
- * In the official CSS spec these are called "simple selectors".
- * @param {string} selectorPartString A string containing the selector part
- *     in css format.
- * @constructor
- * @private
- */
-goog.cssom.iframe.style.CssSelectorPart_ = function(selectorPartString) {
-  // Only one CssSelectorPart instance should exist for a given string.
-  var cacheEntry = goog.cssom.iframe.style.CssSelectorPart_.instances_[
-      selectorPartString];
-  if (cacheEntry) {
-    return cacheEntry;
-  }
-  // Optimization to avoid the more-expensive lookahead.
-  var identifiers;
-  if (selectorPartString.match(/[#\.]/)) {
-    // Lookahead regexp, won't work on IE 5.0.
-    identifiers = selectorPartString.split(/(?=[#\.])/);
-  } else {
-    identifiers = [selectorPartString];
-  }
-  var properties = {};
-  for (var i = 0; i < identifiers.length; i++) {
-    var identifier = identifiers[i];
-    if (identifier.charAt(0) == '.') {
-      properties.className = identifier.substring(1, identifier.length);
-    } else if (identifier.charAt(0) == '#') {
-      properties.id = identifier.substring(1, identifier.length);
-    } else {
-      properties.tagName = identifier.toUpperCase();
-    }
-  }
-  this.inputString_ = selectorPartString;
-  this.matchProperties_ = properties;
-  this.testedElements_ = {};
-  goog.cssom.iframe.style.CssSelectorPart_.instances_[selectorPartString] =
-      this;
-};
-/**
- * Cache of existing CssSelectorPart_ instances.
- * @type {Object}
- * @private
- */
-goog.cssom.iframe.style.CssSelectorPart_.instances_ = {};
-/**
- * Test whether an element matches this selector part, considered in isolation.
- * @param {Object} elementInfo Element properties to test.
- * @return {boolean} Whether the element matched.
- */
-goog.cssom.iframe.style.CssSelectorPart_.prototype.testElement =
-    function(elementInfo) {
-  var elementUid = elementInfo.uid;
-  var cachedMatch = this.testedElements_[elementUid];
-  if (typeof cachedMatch != 'undefined') {
-    return cachedMatch;
-  }
-  var matchProperties = this.matchProperties_;
-  var testTag = matchProperties.tagName;
-  var testClass = matchProperties.className;
-  var testId = matchProperties.id;
-  var matched = true;
-  if (testTag && testTag != '*' && testTag != elementInfo.nodeName) {
-    matched = false;
-  } else if (testId && testId != elementInfo.id) {
-    matched = false;
-  } else if (testClass &&
-             !elementInfo.classNames[testClass]) {
-    matched = false;
-  }
-  this.testedElements_[elementUid] = matched;
-  return matched;
-};
-/**
- * Represents an element and all its parent/ancestor nodes.
- * This class exists as an optimization so we run tests on an element
- * hierarchy multiple times without walking the dom each time.
- * @param {Element} node The DOM element whose ancestry should be stored.
- * @constructor
- * @private
- */
-goog.cssom.iframe.style.NodeAncestry_ = function(node) {
-  var nodeUid = goog.getUid(node);
-  // Return an existing object from the cache if one exits for this node.
-  var ancestry = goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid];
-  if (ancestry) {
-    return ancestry;
-  }
-  var nodes = [];
-  do {
-    var nodeInfo = {
-      id: node.id,
-      nodeName: node.nodeName
-    };
-    nodeInfo.uid = goog.getUid(nodeInfo);
-    var className = node.className;
-    var classNamesLookup = {};
-    if (className) {
-      var classNames = goog.dom.classes.get(node);
-      for (var i = 0; i < classNames.length; i++) {
-        classNamesLookup[classNames[i]] = 1;
-      }
-    }
-    nodeInfo.classNames = classNamesLookup;
-    nodes.unshift(nodeInfo);
-  } while (node = node.parentNode);
-  /**
-   * Array of nodes in order of hierarchy from the top of the document
-   * to the node passed to the constructor
-   * @type {Array.<Node>}
-   */
-  this.nodes = nodes;
-  this.uid = goog.getUid(this);
-  goog.cssom.iframe.style.NodeAncestry_.instances_[nodeUid] = this;
-};
-/**
- * Object for caching existing NodeAncestry instances.
- * @private
- */
-goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
-/**
- * Throw away all cached dom information. Call this if you've modified
- * the structure or class/id attributes of your document and you want
- * to recalculate the currently applied CSS rules.
- */
-goog.cssom.iframe.style.resetDomCache = function() {
-  goog.cssom.iframe.style.NodeAncestry_.instances_ = {};
-};
-/**
- * Inspects a document and returns all active rule sets
- * @param {Document} doc The document from which to read CSS rules.
- * @return {Array.<goog.cssom.iframe.style.CssRuleSet_>} An array of CssRuleSet
- *     objects representing all the active rule sets in the document.
- * @private
- */
-goog.cssom.iframe.style.getRuleSetsFromDocument_ = function(doc) {
-  var ruleSets = [];
-  var styleSheets = goog.cssom.getAllCssStyleSheets(doc.styleSheets);
-  for (var i = 0, styleSheet; styleSheet = styleSheets[i]; i++) {
-    var domRuleSets = goog.cssom.getCssRulesFromStyleSheet(styleSheet);
-    if (domRuleSets && domRuleSets.length) {
-      for (var j = 0, n = domRuleSets.length; j < n; j++) {
-        var ruleSet = new goog.cssom.iframe.style.CssRuleSet_();
-        if (ruleSet.initializeFromCssRule(domRuleSets[j])) {
-          ruleSets.push(ruleSet);
-        }
-      }
-    }
-  }
-  return ruleSets;
-};
-/**
- * Static object to cache rulesets read from documents. Inspecting all
- * active css rules is an expensive operation, so its best to only do
- * it once and then cache the results.
- * @type {Object}
- * @private
- */
-goog.cssom.iframe.style.ruleSetCache_ = {};
-/**
- * Cache of ruleset objects keyed by document unique ID.
- * @type {Object}
- * @private
- */
-goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_ = {};
-/**
- * Loads ruleset definitions from a document. If the cache already
- * has rulesets for this document the cached version will be replaced.
- * @param {Document} doc The document from which to load rulesets.
- */
-goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument = function(doc) {
-  var docUid = goog.getUid(doc);
-  goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_[docUid] =
-      goog.cssom.iframe.style.getRuleSetsFromDocument_(doc);
-};
-/**
- * Retrieves the array of css rulesets for this document. A cached
- * version will be used when possible.
- * @param {Document} doc The document for which to get rulesets.
- * @return {Array.<goog.cssom.iframe.style.CssRuleSet_>} An array of CssRuleSet
- *     objects representing the css rule sets in the supplied document.
- */
-goog.cssom.iframe.style.ruleSetCache_.getRuleSetsForDocument = function(doc) {
-  var docUid = goog.getUid(doc);
-  var cache = goog.cssom.iframe.style.ruleSetCache_.ruleSetCache_;
-  if (!cache[docUid]) {
-    goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(doc);
-  }
-  // Build a cloned copy of rulesets array, so if object in the returned array
-  // get modified future calls will still return the original unmodified
-  // versions.
-  var ruleSets = cache[docUid];
-  var ruleSetsCopy = [];
-  for (var i = 0; i < ruleSets.length; i++) {
-    ruleSetsCopy.push(ruleSets[i].clone());
-  }
-  return ruleSetsCopy;
-};
-/**
- * Array of CSS properties that are inherited by child nodes, according to
- * the CSS 2.1 spec. Properties that may be set to relative values, such
- * as font-size, and line-height, are omitted.
- * @type {Array.<string>}
- * @private
- */
-goog.cssom.iframe.style.inheritedProperties_ = [
-  'color',
-  'visibility',
-  'quotes',
-  'list-style-type',
-  'list-style-image',
-  'list-style-position',
-  'list-style',
-  'page-break-inside',
-  'orphans',
-  'widows',
-  'font-family',
-  'font-style',
-  'font-variant',
-  'font-weight',
-  'text-indent',
-  'text-align',
-  'text-transform',
-  'white-space',
-  'caption-side',
-  'border-collapse',
-  'border-spacing',
-  'empty-cells',
-  'cursor'
-];
-/**
- * Array of CSS 2.1 properties that directly effect text nodes.
- * @type {Array.<string>}
- * @private
- */
-goog.cssom.iframe.style.textProperties_ = [
-  'font-family',
-  'font-size',
-  'font-weight',
-  'font-variant',
-  'font-style',
-  'color',
-  'text-align',
-  'text-decoration',
-  'text-indent',
-  'text-transform',
-  'letter-spacing',
-  'white-space',
-  'word-spacing'
-];
-/**
- * Reads the current css rules from element's document, and returns them
- * rewriting selectors so that any rules that formerly applied to element will
- * be applied to doc.body. This makes it possible to replace a block in a page
- * with an iframe and preserve the css styling of the contents.
- *
- * @param {Element} element The element for which context should be calculated.
- * @param {boolean=} opt_forceRuleSetCacheUpdate Flag to force the internal
- *     cache of rulesets to refresh itself before we read the same.
- * @param {boolean=} opt_copyBackgroundContext Flag indicating that if the
- *     {@code element} has a transparent background, background rules
- *     from the nearest ancestor element(s) that have background-color
- *     and/or background-image set should be copied.
- * @return {string} String containing all CSS rules present in the original
- *     document, with modified selectors.
- * @see goog.cssom.iframe.style.getBackgroundContext.
- */
-goog.cssom.iframe.style.getElementContext = function(
-    element,
-    opt_forceRuleSetCacheUpdate,
-    opt_copyBackgroundContext) {
-  var sourceDocument = element.ownerDocument;
-  if (opt_forceRuleSetCacheUpdate) {
-    goog.cssom.iframe.style.ruleSetCache_.loadRuleSetsForDocument(
-        sourceDocument);
-  }
-  var ruleSets = goog.cssom.iframe.style.ruleSetCache_.
-      getRuleSetsForDocument(sourceDocument);
-  var elementAncestry = new goog.cssom.iframe.style.NodeAncestry_(element);
-  var bodySelectorPart = new goog.cssom.iframe.style.CssSelectorPart_('body');
-  for (var i = 0; i < ruleSets.length; i++) {
-    var ruleSet = ruleSets[i];
-    var selectors = ruleSet.selectors;
-    // Cache selectors.length since we may be adding rules in the loop.
-    var ruleCount = selectors.length;
-    for (var j = 0; j < ruleCount; j++) {
-      var selector = selectors[j];
-      // Test whether all or part of this selector would match
-      // this element or one of its ancestors
-      var match = selector.matchElementAncestry(elementAncestry);
-      if (match) {
-        var ruleIndex = match.selectorPartIndex;
-        var selectorParts = selector.parts;
-        var lastSelectorPartIndex = selectorParts.length - 1;
-        var selectorCopy;
-        if (match.elementIndex == elementAncestry.nodes.length - 1 ||
-            ruleIndex < lastSelectorPartIndex) {
-          // Either the first part(s) of the selector matched this element,
-          // or the first part(s) of the selector matched a parent element
-          // and there are more parts of the selector that could target
-          // children of this element.
-          // So we inject a new selector, replacing the part that matched this
-          // element with 'body' so it will continue to match.
-          var selectorPartsCopy = selectorParts.concat();
-          selectorPartsCopy.splice(0,
-                                   ruleIndex + 1,
-                                   bodySelectorPart);
-          selectorCopy = new goog.cssom.iframe.style.CssSelector_();
-          selectorCopy.parts = selectorPartsCopy;
-          selectors.push(selectorCopy);
-        } else if (ruleIndex > 0 && ruleIndex == lastSelectorPartIndex) {
-          // The rule didn't match this element, but the entire rule did
-          // match an ancestor element. In this case we want to copy
-          // just the last part of the rule, to give it a chance to be applied
-          // to additional matching elements inside this element.
-          // Example DOM structure: body > div.funky > ul > li#editme
-          // Example CSS selector: .funky ul
-          // New CSS selector: body ul
-          selectorCopy = new goog.cssom.iframe.style.CssSelector_();
-          selectorCopy.parts = [
-            bodySelectorPart,
-            selectorParts[lastSelectorPartIndex]
-          ];
-          selectors.push(selectorCopy);
-        }
-      }
-    }
-  }
-  // Insert a new ruleset, setting the current inheritable styles of this
-  // element as the defaults for everything under in the frame.
-  var defaultPropertiesRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
-  var declarationParts = [];
-  var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(element);
-  // Copy inheritable styles so they are applied to everything under HTML.
-  var htmlSelector = new goog.cssom.iframe.style.CssSelector_();
-  htmlSelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_('html')];
-  defaultPropertiesRuleSet.selectors = [htmlSelector];
-  var defaultProperties = {};
-  for (var i = 0, prop;
-       prop = goog.cssom.iframe.style.inheritedProperties_[i];
-       i++) {
-    defaultProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
-  }
-  defaultPropertiesRuleSet.setDeclarationTextFromObject(defaultProperties);
-  ruleSets.push(defaultPropertiesRuleSet);
-  var bodyRuleSet = new goog.cssom.iframe.style.CssRuleSet_();
-  var bodySelector = new goog.cssom.iframe.style.CssSelector_();
-  bodySelector.parts = [new goog.cssom.iframe.style.CssSelectorPart_('body')];
-  // Core set of sane property values for BODY, to prevent copied
-  // styles from completely breaking the display.
-  var bodyProperties = {
-    position: 'relative',
-    top: '0',
-    left: '0',
-    right: 'auto', // Override any existing right value so 'left' works.
-    display: 'block',
-    visibility: 'visible'
-  };
-  // Text formatting property values, to keep text nodes directly under BODY
-  // looking right.
-  for (i = 0, prop; prop = goog.cssom.iframe.style.textProperties_[i]; i++) {
-    bodyProperties[prop] = computedStyle[goog.string.toCamelCase(prop)];
-  }
-  if (opt_copyBackgroundContext &&
-      goog.cssom.iframe.style.isTransparentValue_(
-          computedStyle['backgroundColor'])) {
-    // opt_useAncestorBackgroundRules means that, if the original element
-    // has a transparent backgorund, background properties rules should be
-    // added to explicitly make the body have the same background appearance
-    // as in the original element, even if its positioned somewhere else
-    // in the DOM.
-    var bgProperties =
-        goog.cssom.iframe.style.getBackgroundContext(element);
-    bodyProperties['background-color'] = bgProperties['backgroundColor'];
-    var elementBgImage = computedStyle['backgroundImage'];
-    if (!elementBgImage || elementBgImage == 'none') {
-      bodyProperties['background-image'] = bgProperties['backgroundImage'];
-      bodyProperties['background-repeat'] = bgProperties['backgroundRepeat'];
-      bodyProperties['background-position'] =
-          bgProperties['backgroundPosition'];
-    }
-  }
-  bodyRuleSet.setDeclarationTextFromObject(bodyProperties, true);
-  bodyRuleSet.selectors = [bodySelector];
-  ruleSets.push(bodyRuleSet);
-  // Write outputTextParts to doc.
-  var ruleSetStrings = [];
-  ruleCount = ruleSets.length;
-  for (i = 0; i < ruleCount; i++) {
-    ruleSets[i].writeToArray(ruleSetStrings);
-  }
-  return ruleSetStrings.join('');
-};
-/**
- * Tests whether a value is equivalent to 'transparent'.
- * @param {string} colorValue The value to test.
- * @return {boolean} Whether the value is transparent.
- * @private
- */
-goog.cssom.iframe.style.isTransparentValue_ = function(colorValue) {
-  return colorValue == 'transparent' || colorValue == 'rgba(0, 0, 0, 0)';
-};
-/**
- * Returns an object containing the set of computedStyle/currentStyle
- * values for the given element. Note that this should be used with
- * caution as it ignores the fact that currentStyle and computedStyle
- * are not the same for certain properties.
- *
- * @param {Element} element The element whose computed style to return.
- * @return {Object} Object containing style properties and values.
- * @private
- */
-goog.cssom.iframe.style.getComputedStyleObject_ = function(element) {
-  // Return an object containing the element's computedStyle/currentStyle.
-  // The resulting object can be re-used to read multiple properties, which
-  // is faster than calling goog.style.getComputedStyle every time.
-  return element.currentStyle ||
-      goog.dom.getOwnerDocument(element).defaultView.getComputedStyle(
-          element, '') || {};
-};
-/**
- * RegExp that splits a value like "10px" or "-1em" into parts.
- * @private
- * @type {RegExp}
- */
-goog.cssom.iframe.style.valueWithUnitsRegEx_ = /^(-?)([0-9]+)([a-z]*|%)/;
-/**
- * Given an object containing a set of styles, returns a two-element array
- * containing the values of background-position-x and background-position-y.
- * @param {Object} styleObject Object from which to read style properties.
- * @return {Array.<string>} The background-position values in the order [x, y].
- * @private
- */
-goog.cssom.iframe.style.getBackgroundXYValues_ = function(styleObject) {
-  // Gecko only has backgroundPosition, containing both values.
-  // IE has only backgroundPositionX/backgroundPositionY.
-  // WebKit has both.
-  if (styleObject['backgroundPositionY']) {
-    return [styleObject['backgroundPositionX'],
-            styleObject['backgroundPositionY']];
-  } else {
-    return (styleObject['backgroundPosition'] || '0 0').split(' ');
-  }
-};
-/**
- * Generates a set of CSS properties that can be used to make another
- * element's background look like the background of a given element.
- * This is useful when you want to copy the CSS context of an element,
- * but the element's background is transparent. In the original context
- * you would see the ancestor's backround color/image showing through,
- * but in the new context there might be a something different underneath.
- * Note that this assumes the element you're copying context from has a
- * fairly standard positioning/layout - it assumes that when the element
- * has a transparent background what you're going to see through it is its
- * ancestors.
- * @param {Element} element The element from which to copy background styles.
- * @return {Object} Object containing background* properties.
- */
-goog.cssom.iframe.style.getBackgroundContext = function(element) {
-  var propertyValues = {
-    'backgroundImage': 'none'
-  };
-  var ancestor = element;
-  var currentIframeWindow;
-  // Walk up the DOM tree to find the ancestor nodes whose backgrounds
-  // may be visible underneath this element. Background-image and
-  // background-color don't have to come from the same node, but as soon
-  // an element with background-color is found there's no need to continue
-  // because backgrounds farther up the chain won't be visible.
-  // (This implementation is not sophisticated enough to handle opacity,
-  // or multple layered partially-transparent background images.)
-  while ((ancestor = ancestor.parentNode) &&
-         ancestor.nodeType == goog.dom.NodeType.ELEMENT) {
-    var computedStyle = goog.cssom.iframe.style.getComputedStyleObject_(
-        /** @type {Element} */ (ancestor));
-    // Copy background color if a non-transparent value is found.
-    var backgroundColorValue = computedStyle['backgroundColor'];
-    if (!goog.cssom.iframe.style.isTransparentValue_(backgroundColorValue)) {
-      propertyValues['backgroundColor'] = backgroundColorValue;
-    }
-    // If a background image value is found, copy background-image,
-    // background-repeat, and background-position.
-    if (computedStyle['backgroundImage'] &&
-        computedStyle['backgroundImage'] != 'none') {
-      propertyValues['backgroundImage'] = computedStyle['backgroundImage'];
-      propertyValues['backgroundRepeat'] = computedStyle['backgroundRepeat'];
-      // Calculate the offset between the original element and the element
-      // providing the background image, so the background position can be
-      // adjusted.
-      var relativePosition;
-      if (currentIframeWindow) {
-        relativePosition = goog.style.getFramedPageOffset(
-            element, currentIframeWindow);
-        var frameElement = currentIframeWindow.frameElement;
-        var iframeRelativePosition = goog.style.getRelativePosition(
-            /** @type {Element} */ (frameElement),
-            /** @type {Element} */ (ancestor));
-        var iframeBorders = goog.style.getBorderBox(frameElement);
-        relativePosition.x += iframeRelativePosition.x + iframeBorders.left;
-        relativePosition.y += iframeRelativePosition.y + iframeBorders.top;
-      } else {
-        relativePosition = goog.style.getRelativePosition(
-            element, /** @type {Element} */ (ancestor));
-      }
-      var backgroundXYValues = goog.cssom.iframe.style.getBackgroundXYValues_(
-          computedStyle);
-      // Parse background-repeat-* values in the form "10px", and adjust them.
-      for (var i = 0; i < 2; i++) {
-        var positionValue = backgroundXYValues[i];
-        var coordinate = i == 0 ? 'X' : 'Y';
-        var positionProperty = 'backgroundPosition' + coordinate;
-        // relative position to its ancestor.
-        var positionValueParts =
-            goog.cssom.iframe.style.valueWithUnitsRegEx_.exec(positionValue);
-        if (positionValueParts) {
-          var value = parseInt(
-              positionValueParts[1] + positionValueParts[2], 10);
-          var units = positionValueParts[3];
-          // This only attempts to handle pixel values for now (plus
-          // '0anything', which is equivalent to 0px).
-          // TODO(user) Convert non-pixel values to pixels when possible.
-          if (value == 0 || units == 'px') {
-            value -= (coordinate == 'X' ?
-                      relativePosition.x : relativePosition.y);
-          }
-          positionValue = value + units;
-        }
-        propertyValues[positionProperty] = positionValue;
-      }
-      propertyValues['backgroundPosition'] =
-          propertyValues['backgroundPositionX'] + ' ' +
-          propertyValues['backgroundPositionY'];
-    }
-    if (propertyValues['backgroundColor']) {
-      break;
-    }
-    if (ancestor.tagName == goog.dom.TagName.HTML) {
-      try {
-        currentIframeWindow = goog.dom.getWindow(
-            /** @type {Document} */ (ancestor.parentNode));
-        // This could theoretically throw a security exception if the parent
-        // iframe is in a different domain.
-        ancestor = currentIframeWindow.frameElement;
-        if (!ancestor) {
-          // Loop has reached the top level window.
-          break;
-        }
-      } catch (e) {
-        // We don't have permission to go up to the parent window, stop here.
-        break;
-      }
-    }
-  }
-  return propertyValues;
-};