// Extracts the url from an import rule, supported formats:
// - 'url' / "url",
// - url(url) / url('url') / url("url")
function _extractUrl(importRule: string): string {
  var match = RegExpWrapper.firstMatch(_urlRe, importRule);
  if (isBlank(match)) return null;
  return isPresent(match[1]) ? match[1] : match[2];
}

function _withCssRules(cssText: string, callback: Function) {
  // Difference from webcomponentjs: remove the workaround for an old bug in Chrome
  if (isBlank(callback)) return;
  var rules = _cssToRules(cssText);
  callback(rules);
}

 eval(context, locals: Locals): any {
   var evaluatedReceiver = this.receiver.eval(context, locals);
   if (isBlank(evaluatedReceiver)) return null;
   var evaluatedArgs = evalList(context, locals, this.args);
   return this.fn(evaluatedReceiver, evaluatedArgs);
 }

export function browserPlatform(): PlatformRef {
  if (isBlank(getPlatform())) {
    createPlatform(ReflectiveInjector.resolveAndCreate(BROWSER_PROVIDERS));
  }
  return assertPlatform(BROWSER_PLATFORM_MARKER);
}

export function isDefaultChangeDetectionStrategy(
    changeDetectionStrategy: ChangeDetectionStrategy): boolean {
  return isBlank(changeDetectionStrategy) ||
         changeDetectionStrategy === ChangeDetectionStrategy.Default;
}

  _inlineImports(cssText: string, baseUrl: string, inlinedUrls: List<string>): Promise<string>|string {
    var partIndex = 0;
    var parts = StringWrapper.split(cssText, _importRe);

    if (parts.length === 1) {
      // no @import rule found, return the original css
      return cssText;
    }

    var promises = [];

    while (partIndex < parts.length - 1) {
      // prefix is the content before the @import rule
      var prefix = parts[partIndex];
      // rule is the parameter of the @import rule
      var rule = parts[partIndex + 1];
      var url = _extractUrl(rule);
      if (isPresent(url)) {
        url = this._urlResolver.resolve(baseUrl, url);
      }
      var mediaQuery = _extractMediaQuery(rule);
      var promise;

      if (isBlank(url)) {
        promise = PromiseWrapper.resolve(`/* Invalid import rule: "@import ${rule};" */`);
      } else if (ListWrapper.contains(inlinedUrls, url)) {
        // The current import rule has already been inlined, return the prefix only
        // Importing again might cause a circular dependency
        promise = PromiseWrapper.resolve(prefix);
      } else {
        ListWrapper.push(inlinedUrls, url);
        promise = PromiseWrapper.then(
          this._xhr.get(url),
          (css) => {
            // resolve nested @import rules
            css = this._inlineImports(css, url, inlinedUrls);
            if (PromiseWrapper.isPromise(css)) {
              // wait until nested @import are inlined
              return css.then((css) => {
                return prefix + this._transformImportedCss(css, mediaQuery, url) + '\n'
              }) ;
            } else {
              // there are no nested @import, return the css
              return prefix + this._transformImportedCss(css, mediaQuery, url) + '\n';
            }
          },
          (error) => `/* failed to import ${url} */\n`
        );
      }
      ListWrapper.push(promises, promise);
      partIndex += 2;
    }

    return PromiseWrapper.all(promises).then(function (cssParts) {
      var cssText = cssParts.join('');
      if (partIndex < parts.length) {
        // append then content located after the last @import rule
        cssText += parts[partIndex];
      }
      return cssText;
    });
  }

 _createView(protoView) {
   var rootElementClone = protoView.isRootView ? protoView.element : DOM.importIntoDoc(protoView.element);
   var elementsWithBindingsDynamic;
   if (protoView.isTemplateElement) {
     elementsWithBindingsDynamic = DOM.querySelectorAll(DOM.content(rootElementClone), NG_BINDING_CLASS_SELECTOR);
   } else {
     elementsWithBindingsDynamic = DOM.getElementsByClassName(rootElementClone, NG_BINDING_CLASS);
   }
   var elementsWithBindings = ListWrapper.createFixedSize(elementsWithBindingsDynamic.length);
   for (var binderIdx = 0; binderIdx < elementsWithBindingsDynamic.length; ++binderIdx) {
     elementsWithBindings[binderIdx] = elementsWithBindingsDynamic[binderIdx];
   }
   var viewRootNodes;
   if (protoView.isTemplateElement) {
     var childNode = DOM.firstChild(DOM.content(rootElementClone));
     viewRootNodes = [];
     while (childNode != null) {
       ListWrapper.push(viewRootNodes, childNode);
       childNode = DOM.nextSibling(childNode);
     }
   } else {
     viewRootNodes = [rootElementClone];
   }
   var binders = protoView.elementBinders;
   var boundTextNodes = [];
   var boundElements = ListWrapper.createFixedSize(binders.length);
   var viewContainers = ListWrapper.createFixedSize(binders.length);
   var contentTags = ListWrapper.createFixedSize(binders.length);
   for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) {
     var binder = binders[binderIdx];
     var element;
     if (binderIdx === 0 && protoView.rootBindingOffset === 1) {
       element = rootElementClone;
     } else {
       element = elementsWithBindings[binderIdx - protoView.rootBindingOffset];
     }
     boundElements[binderIdx] = element;
     var childNodes = DOM.childNodes(DOM.templateAwareRoot(element));
     var textNodeIndices = binder.textNodeIndices;
     for (var i = 0; i < textNodeIndices.length; i++) {
       ListWrapper.push(boundTextNodes, childNodes[textNodeIndices[i]]);
     }
     var viewContainer = null;
     if (isBlank(binder.componentId) && isPresent(binder.nestedProtoView)) {
       viewContainer = new ViewContainer(this, element);
     }
     viewContainers[binderIdx] = viewContainer;
     var contentTag = null;
     if (isPresent(binder.contentTagSelector)) {
       contentTag = new Content(element, binder.contentTagSelector);
     }
     contentTags[binderIdx] = contentTag;
   }
   var view = new View(protoView, viewRootNodes, boundTextNodes, boundElements, viewContainers, contentTags);
   for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) {
     var binder = binders[binderIdx];
     var element = boundElements[binderIdx];
     if (isPresent(binder.componentId) && isPresent(binder.nestedProtoView)) {
       var childView = this._createView(binder.nestedProtoView);
       view.setComponentView(this._shadowDomStrategy, binderIdx, childView);
     }
     if (isPresent(binder.eventLocals)) {
       ListWrapper.forEach(binder.eventNames, (eventName) => {
         this._createEventListener(view, element, binderIdx, eventName, binder.eventLocals);
       });
     }
   }
   if (protoView.isRootView) {
     view.hydrate(null);
   }
   return view;
 }

 isDefaultChangeDetection(): boolean {
   return isBlank(this.directiveRecord) || this.directiveRecord.isDefaultChangeDetection();
 }

function toHtml(nodes) {
  if (isBlank(nodes))
    return [];
  return ListWrapper.map(nodes, DOM.getOuterHTML);
}

 function expectEvalError(text, passedInContext = null, passedInLocals = null) {
   var c = isBlank(passedInContext) ? td() : passedInContext;
   var l = isBlank(passedInLocals) ? emptyLocals() : passedInLocals;
   return expect(() => parseAction(text).eval(c, l));
 }