sdk/pkg/dev_compiler/lib/runtime/dart/html_common.js

dart_library.library('dart/html_common', null, /* Imports */[
  'dart/_runtime',
  'dart/_metadata',
  'dart/core',
  'dart/html',
  'dart/typed_data',
  'dart/_js_helper',
  'dart/_native_typed_data',
  'dart/async',
  'dart/collection',
  'dart/_internal'
], /* Lazy imports */[
], function(exports, dart, _metadata, core, html, typed_data, _js_helper, _native_typed_data, async, collection, _internal) {
  'use strict';
  let dartx = dart.dartx;
  dart.export(exports, _metadata);
  const _validateToken = Symbol('_validateToken');
  class CssClassSetImpl extends core.Object {
    [_validateToken](value) {
      if (dart.notNull(CssClassSetImpl._validTokenRE.hasMatch(value))) return value;
      dart.throw(new core.ArgumentError.value(value, 'value', 'Not a valid class token'));
    }
    toString() {
      return this.readClasses().join(' ');
    }
    toggle(value, shouldAdd) {
      if (shouldAdd === void 0) shouldAdd = null;
      this[_validateToken](value);
      let s = this.readClasses();
      let result = false;
      if (shouldAdd == null) shouldAdd = !dart.notNull(s.contains(value));
      if (dart.notNull(shouldAdd)) {
        s.add(value);
        result = true;
      } else {
        s.remove(value);
      }
      this.writeClasses(s);
      return result;
    }
    get frozen() {
      return false;
    }
    get iterator() {
      return this.readClasses().iterator;
    }
    [Symbol.iterator]() {
      return new dart.JsIterator(this.iterator);
    }
    forEach(f) {
      this.readClasses().forEach(f);
    }
    join(separator) {
      if (separator === void 0) separator = "";
      return this.readClasses().join(separator);
    }
    map(f) {
      return this.readClasses().map(f);
    }
    where(f) {
      return this.readClasses().where(f);
    }
    expand(f) {
      return this.readClasses().expand(f);
    }
    every(f) {
      return this.readClasses().every(f);
    }
    any(f) {
      return this.readClasses().any(f);
    }
    get isEmpty() {
      return this.readClasses().isEmpty;
    }
    get isNotEmpty() {
      return this.readClasses().isNotEmpty;
    }
    get length() {
      return this.readClasses().length;
    }
    reduce(combine) {
      return this.readClasses().reduce(combine);
    }
    fold(initialValue, combine) {
      return this.readClasses().fold(initialValue, combine);
    }
    contains(value) {
      if (!(typeof value == 'string')) return false;
      this[_validateToken](dart.as(value, core.String));
      return this.readClasses().contains(value);
    }
    lookup(value) {
      return dart.as(dart.notNull(this.contains(value)) ? value : null, core.String);
    }
    add(value) {
      this[_validateToken](value);
      return dart.as(this.modify(dart.fn(s => s.add(value), core.bool, [core.Set$(core.String)])), core.bool);
    }
    remove(value) {
      this[_validateToken](dart.as(value, core.String));
      if (!(typeof value == 'string')) return false;
      let s = this.readClasses();
      let result = s.remove(value);
      this.writeClasses(s);
      return result;
    }
    addAll(iterable) {
      this.modify(dart.fn((s => s.addAll(iterable[dartx.map](dart.bind(this, _validateToken)))).bind(this), dart.void, [core.Set$(core.String)]));
    }
    removeAll(iterable) {
      this.modify(dart.fn((s => s.removeAll(iterable[dartx.map](dart.as(dart.bind(this, _validateToken), __CastType0)))).bind(this), dart.void, [core.Set$(core.String)]));
    }
    toggleAll(iterable, shouldAdd) {
      if (shouldAdd === void 0) shouldAdd = null;
      iterable[dartx.forEach](dart.fn((e => this.toggle(e, shouldAdd)).bind(this), core.bool, [core.String]));
    }
    retainAll(iterable) {
      this.modify(dart.fn(s => s.retainAll(iterable), dart.void, [core.Set$(core.String)]));
    }
    removeWhere(test) {
      this.modify(dart.fn(s => s.removeWhere(test), dart.void, [core.Set$(core.String)]));
    }
    retainWhere(test) {
      this.modify(dart.fn(s => s.retainWhere(test), dart.void, [core.Set$(core.String)]));
    }
    containsAll(collection) {
      return this.readClasses().containsAll(collection);
    }
    intersection(other) {
      return this.readClasses().intersection(other);
    }
    union(other) {
      return this.readClasses().union(other);
    }
    difference(other) {
      return this.readClasses().difference(other);
    }
    get first() {
      return this.readClasses().first;
    }
    get last() {
      return this.readClasses().last;
    }
    get single() {
      return this.readClasses().single;
    }
    toList(opts) {
      let growable = opts && 'growable' in opts ? opts.growable : true;
      return this.readClasses().toList({growable: growable});
    }
    toSet() {
      return this.readClasses().toSet();
    }
    take(n) {
      return this.readClasses().take(n);
    }
    takeWhile(test) {
      return this.readClasses().takeWhile(test);
    }
    skip(n) {
      return this.readClasses().skip(n);
    }
    skipWhile(test) {
      return this.readClasses().skipWhile(test);
    }
    firstWhere(test, opts) {
      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
      return this.readClasses().firstWhere(test, {orElse: orElse});
    }
    lastWhere(test, opts) {
      let orElse = opts && 'orElse' in opts ? opts.orElse : null;
      return this.readClasses().lastWhere(test, {orElse: orElse});
    }
    singleWhere(test) {
      return this.readClasses().singleWhere(test);
    }
    elementAt(index) {
      return this.readClasses().elementAt(index);
    }
    clear() {
      this.modify(dart.fn(s => s.clear(), dart.void, [core.Set$(core.String)]));
    }
    modify(f) {
      let s = this.readClasses();
      let ret = f(s);
      this.writeClasses(s);
      return ret;
    }
  }
  CssClassSetImpl[dart.implements] = () => [html.CssClassSet];
  dart.setSignature(CssClassSetImpl, {
    methods: () => ({
      [_validateToken]: [core.String, [core.String]],
      toggle: [core.bool, [core.String], [core.bool]],
      forEach: [dart.void, [dart.functionType(dart.void, [core.String])]],
      join: [core.String, [], [core.String]],
      map: [core.Iterable, [dart.functionType(dart.dynamic, [core.String])]],
      where: [core.Iterable$(core.String), [dart.functionType(core.bool, [core.String])]],
      expand: [core.Iterable, [dart.functionType(core.Iterable, [core.String])]],
      every: [core.bool, [dart.functionType(core.bool, [core.String])]],
      any: [core.bool, [dart.functionType(core.bool, [core.String])]],
      reduce: [core.String, [dart.functionType(core.String, [core.String, core.String])]],
      fold: [dart.dynamic, [dart.dynamic, dart.functionType(dart.dynamic, [dart.dynamic, core.String])]],
      contains: [core.bool, [core.Object]],
      lookup: [core.String, [core.Object]],
      add: [core.bool, [core.String]],
      remove: [core.bool, [core.Object]],
      addAll: [dart.void, [core.Iterable$(core.String)]],
      removeAll: [dart.void, [core.Iterable$(core.Object)]],
      toggleAll: [dart.void, [core.Iterable$(core.String)], [core.bool]],
      retainAll: [dart.void, [core.Iterable$(core.Object)]],
      removeWhere: [dart.void, [dart.functionType(core.bool, [core.String])]],
      retainWhere: [dart.void, [dart.functionType(core.bool, [core.String])]],
      containsAll: [core.bool, [core.Iterable$(core.Object)]],
      intersection: [core.Set$(core.String), [core.Set$(core.Object)]],
      union: [core.Set$(core.String), [core.Set$(core.String)]],
      difference: [core.Set$(core.String), [core.Set$(core.String)]],
      toList: [core.List$(core.String), [], {growable: core.bool}],
      toSet: [core.Set$(core.String), []],
      take: [core.Iterable$(core.String), [core.int]],
      takeWhile: [core.Iterable$(core.String), [dart.functionType(core.bool, [core.String])]],
      skip: [core.Iterable$(core.String), [core.int]],
      skipWhile: [core.Iterable$(core.String), [dart.functionType(core.bool, [core.String])]],
      firstWhere: [core.String, [dart.functionType(core.bool, [core.String])], {orElse: dart.functionType(core.String, [])}],
      lastWhere: [core.String, [dart.functionType(core.bool, [core.String])], {orElse: dart.functionType(core.String, [])}],
      singleWhere: [core.String, [dart.functionType(core.bool, [core.String])]],
      elementAt: [core.String, [core.int]],
      clear: [dart.void, []],
      modify: [dart.dynamic, [dart.functionType(dart.dynamic, [core.Set$(core.String)])]]
    })
  });
  dart.defineExtensionMembers(CssClassSetImpl, [
    'forEach',
    'join',
    'map',
    'where',
    'expand',
    'every',
    'any',
    'reduce',
    'fold',
    'contains',
    'toList',
    'toSet',
    'take',
    'takeWhile',
    'skip',
    'skipWhile',
    'firstWhere',
    'lastWhere',
    'singleWhere',
    'elementAt',
    'iterator',
    'isEmpty',
    'isNotEmpty',
    'length',
    'first',
    'last',
    'single'
  ]);
  dart.defineLazyProperties(CssClassSetImpl, {
    get _validTokenRE() {
      return core.RegExp.new('^\\S+$');
    }
  });
  const __CastType0 = dart.typedef('__CastType0', () => dart.functionType(core.String, [core.Object]));
  function convertDartToNative_SerializedScriptValue(value) {
    return convertDartToNative_PrepareForStructuredClone(value);
  }
  dart.fn(convertDartToNative_SerializedScriptValue);
  function convertNativeToDart_SerializedScriptValue(object) {
    return convertNativeToDart_AcceptStructuredClone(object, {mustCopy: true});
  }
  dart.fn(convertNativeToDart_SerializedScriptValue);
  class _StructuredClone extends core.Object {
    _StructuredClone() {
      this.values = [];
      this.copies = [];
    }
    findSlot(value) {
      let length = this.values[dartx.length];
      for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
        if (dart.notNull(core.identical(this.values[dartx.get](i), value))) return i;
      }
      this.values[dartx.add](value);
      this.copies[dartx.add](null);
      return length;
    }
    readSlot(i) {
      return this.copies[dartx.get](i);
    }
    writeSlot(i, x) {
      this.copies[dartx.set](i, x);
    }
    cleanupSlots() {}
    walk(e) {
      if (e == null) return e;
      if (typeof e == 'boolean') return e;
      if (typeof e == 'number') return e;
      if (typeof e == 'string') return e;
      if (dart.is(e, core.DateTime)) {
        return convertDartToNative_DateTime(dart.as(e, core.DateTime));
      }
      if (dart.is(e, core.RegExp)) {
        dart.throw(new core.UnimplementedError('structured clone of RegExp'));
      }
      if (dart.is(e, dart.dynamic)) return e;
      if (dart.is(e, dart.dynamic)) return e;
      if (dart.is(e, dart.dynamic)) return e;
      if (dart.is(e, dart.dynamic)) return e;
      if (dart.notNull(this.cloneNotRequired(e))) return e;
      if (dart.is(e, core.Map)) {
        let slot = this.findSlot(e);
        let copy = this.readSlot(slot);
        if (copy != null) return copy;
        copy = this.newJsMap();
        this.writeSlot(slot, copy);
        dart.dsend(e, 'forEach', dart.fn(((key, value) => {
          this.putIntoMap(copy, key, this.walk(value));
        }).bind(this)));
        return copy;
      }
      if (dart.is(e, core.List)) {
        let slot = this.findSlot(e);
        let copy = this.readSlot(slot);
        if (copy != null) return copy;
        copy = this.copyList(dart.as(e, core.List), slot);
        return copy;
      }
      dart.throw(new core.UnimplementedError('structured clone of other type'));
    }
    copyList(e, slot) {
      let i = 0;
      let length = e[dartx.length];
      let copy = this.newJsList(length);
      this.writeSlot(slot, copy);
      for (; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
        dart.dsetindex(copy, i, this.walk(e[dartx.get](i)));
      }
      return copy;
    }
    convertDartToNative_PrepareForStructuredClone(value) {
      let copy = this.walk(value);
      this.cleanupSlots();
      return copy;
    }
  }
  dart.setSignature(_StructuredClone, {
    methods: () => ({
      findSlot: [core.int, [dart.dynamic]],
      readSlot: [dart.dynamic, [core.int]],
      writeSlot: [dart.dynamic, [core.int, dart.dynamic]],
      cleanupSlots: [dart.dynamic, []],
      walk: [dart.dynamic, [dart.dynamic]],
      copyList: [dart.dynamic, [core.List, core.int]],
      convertDartToNative_PrepareForStructuredClone: [dart.dynamic, [dart.dynamic]]
    })
  });
  class _AcceptStructuredClone extends core.Object {
    _AcceptStructuredClone() {
      this.values = [];
      this.copies = [];
      this.mustCopy = false;
    }
    findSlot(value) {
      let length = this.values[dartx.length];
      for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
        if (dart.notNull(this.identicalInJs(this.values[dartx.get](i), value))) return i;
      }
      this.values[dartx.add](value);
      this.copies[dartx.add](null);
      return length;
    }
    readSlot(i) {
      return this.copies[dartx.get](i);
    }
    writeSlot(i, x) {
      this.copies[dartx.set](i, x);
    }
    walk(e) {
      if (e == null) return e;
      if (typeof e == 'boolean') return e;
      if (typeof e == 'number') return e;
      if (typeof e == 'string') return e;
      if (dart.notNull(isJavaScriptDate(e))) {
        return convertNativeToDart_DateTime(e);
      }
      if (dart.notNull(isJavaScriptRegExp(e))) {
        dart.throw(new core.UnimplementedError('structured clone of RegExp'));
      }
      if (dart.notNull(isJavaScriptPromise(e))) {
        return convertNativePromiseToDartFuture(e);
      }
      if (dart.notNull(isJavaScriptSimpleObject(e))) {
        let slot = this.findSlot(e);
        let copy = this.readSlot(slot);
        if (copy != null) return copy;
        copy = dart.map();
        this.writeSlot(slot, copy);
        this.forEachJsField(e, dart.fn(((key, value) => dart.dsetindex(copy, key, this.walk(value))).bind(this)));
        return copy;
      }
      if (dart.notNull(isJavaScriptArray(e))) {
        let slot = this.findSlot(e);
        let copy = this.readSlot(slot);
        if (copy != null) return copy;
        let length = dart.as(dart.dload(e, 'length'), core.int);
        copy = dart.notNull(this.mustCopy) ? this.newDartList(length) : e;
        this.writeSlot(slot, copy);
        for (let i = 0; dart.notNull(i) < dart.notNull(length); i = dart.notNull(i) + 1) {
          dart.dsetindex(copy, i, this.walk(dart.dindex(e, i)));
        }
        return copy;
      }
      return e;
    }
    convertNativeToDart_AcceptStructuredClone(object, opts) {
      let mustCopy = opts && 'mustCopy' in opts ? opts.mustCopy : false;
      this.mustCopy = dart.as(mustCopy, core.bool);
      let copy = this.walk(object);
      return copy;
    }
  }
  dart.setSignature(_AcceptStructuredClone, {
    methods: () => ({
      findSlot: [core.int, [dart.dynamic]],
      readSlot: [dart.dynamic, [core.int]],
      writeSlot: [dart.dynamic, [core.int, dart.dynamic]],
      walk: [dart.dynamic, [dart.dynamic]],
      convertNativeToDart_AcceptStructuredClone: [dart.dynamic, [dart.dynamic], {mustCopy: dart.dynamic}]
    })
  });
  class _TypedContextAttributes extends core.Object {
    _TypedContextAttributes(alpha, antialias, depth, failIfMajorPerformanceCaveat, premultipliedAlpha, preserveDrawingBuffer, stencil) {
      this.alpha = alpha;
      this.antialias = antialias;
      this.depth = depth;
      this.failIfMajorPerformanceCaveat = failIfMajorPerformanceCaveat;
      this.premultipliedAlpha = premultipliedAlpha;
      this.preserveDrawingBuffer = preserveDrawingBuffer;
      this.stencil = stencil;
    }
  }
  dart.setSignature(_TypedContextAttributes, {
    constructors: () => ({_TypedContextAttributes: [_TypedContextAttributes, [core.bool, core.bool, core.bool, core.bool, core.bool, core.bool, core.bool]]})
  });
  function convertNativeToDart_ContextAttributes(nativeContextAttributes) {
    if (dart.is(nativeContextAttributes, dart.dynamic)) {
      return nativeContextAttributes;
    }
    return new _TypedContextAttributes(dart.as(nativeContextAttributes.alpha, core.bool), dart.as(nativeContextAttributes.antialias, core.bool), dart.as(nativeContextAttributes.depth, core.bool), dart.as(nativeContextAttributes.failIfMajorPerformanceCaveat, core.bool), dart.as(nativeContextAttributes.premultipliedAlpha, core.bool), dart.as(nativeContextAttributes.preserveDrawingBuffer, core.bool), dart.as(nativeContextAttributes.stencil, core.bool));
  }
  dart.fn(convertNativeToDart_ContextAttributes);
  class _TypedImageData extends core.Object {
    _TypedImageData(data, height, width) {
      this.data = data;
      this.height = height;
      this.width = width;
    }
  }
  dart.setSignature(_TypedImageData, {
    constructors: () => ({_TypedImageData: [_TypedImageData, [typed_data.Uint8ClampedList, core.int, core.int]]})
  });
  function convertNativeToDart_ImageData(nativeImageData) {
    0;
    if (dart.is(nativeImageData, dart.dynamic)) {
      let data = dart.dload(nativeImageData, 'data');
      if (data.constructor === Array) {
        if (typeof CanvasPixelArray !== "undefined") {
          data.constructor = CanvasPixelArray;
          data.BYTES_PER_ELEMENT = 1;
        }
      }
      return nativeImageData;
    }
    return new _TypedImageData(dart.as(nativeImageData.data, typed_data.Uint8ClampedList), dart.as(nativeImageData.height, core.int), dart.as(nativeImageData.width, core.int));
  }
  dart.fn(convertNativeToDart_ImageData);
  function convertDartToNative_ImageData(imageData) {
    if (dart.is(imageData, _TypedImageData)) {
      return {data: dart.dload(imageData, 'data'), height: dart.dload(imageData, 'height'), width: dart.dload(imageData, 'width')};
    }
    return imageData;
  }
  dart.fn(convertDartToNative_ImageData);
  const _serializedScriptValue = 'num|String|bool|' + 'JSExtendableArray|=Object|' + 'Blob|File|NativeByteBuffer|NativeTypedData';
  const annotation_Creates_SerializedScriptValue = dart.const(new _js_helper.Creates(_serializedScriptValue));
  const annotation_Returns_SerializedScriptValue = dart.const(new _js_helper.Returns(_serializedScriptValue));
  function convertNativeToDart_Dictionary(object) {
    if (object == null) return null;
    let dict = dart.map();
    let keys = Object.getOwnPropertyNames(object);
    for (let key of dart.as(keys, core.Iterable)) {
      dict.set(key, object[key]);
    }
    return dict;
  }
  dart.fn(convertNativeToDart_Dictionary, core.Map, [dart.dynamic]);
  function convertDartToNative_Dictionary(dict, postCreate) {
    if (postCreate === void 0) postCreate = null;
    if (dict == null) return null;
    let object = {};
    if (postCreate != null) {
      dart.dcall(postCreate, object);
    }
    dict.forEach(dart.fn((key, value) => {
      object[key] = value;
    }, dart.void, [core.String, dart.dynamic]));
    return object;
  }
  dart.fn(convertDartToNative_Dictionary, dart.dynamic, [core.Map], [dart.functionType(dart.void, [dart.dynamic])]);
  function convertDartToNative_StringArray(input) {
    return input;
  }
  dart.fn(convertDartToNative_StringArray, core.List, [core.List$(core.String)]);
  function convertNativeToDart_DateTime(date) {
    let millisSinceEpoch = date.getTime();
    return new core.DateTime.fromMillisecondsSinceEpoch(millisSinceEpoch, {isUtc: true});
  }
  dart.fn(convertNativeToDart_DateTime, core.DateTime, [dart.dynamic]);
  function convertDartToNative_DateTime(date) {
    return new Date(date.millisecondsSinceEpoch);
  }
  dart.fn(convertDartToNative_DateTime, dart.dynamic, [core.DateTime]);
  function convertDartToNative_PrepareForStructuredClone(value) {
    return new _StructuredCloneDart2Js().convertDartToNative_PrepareForStructuredClone(value);
  }
  dart.fn(convertDartToNative_PrepareForStructuredClone);
  function convertNativeToDart_AcceptStructuredClone(object, opts) {
    let mustCopy = opts && 'mustCopy' in opts ? opts.mustCopy : false;
    return new _AcceptStructuredCloneDart2Js().convertNativeToDart_AcceptStructuredClone(object, {mustCopy: mustCopy});
  }
  dart.fn(convertNativeToDart_AcceptStructuredClone, dart.dynamic, [dart.dynamic], {mustCopy: dart.dynamic});
  class _StructuredCloneDart2Js extends _StructuredClone {
    _StructuredCloneDart2Js() {
      super._StructuredClone();
    }
    newJsMap() {
      return {};
    }
    putIntoMap(map, key, value) {
      return map[key] = value;
    }
    newJsList(length) {
      return new Array(length);
    }
    cloneNotRequired(e) {
      return dart.is(e, _native_typed_data.NativeByteBuffer) || dart.is(e, _native_typed_data.NativeTypedData);
    }
  }
  dart.setSignature(_StructuredCloneDart2Js, {
    methods: () => ({
      newJsMap: [dart.dynamic, []],
      putIntoMap: [dart.void, [dart.dynamic, dart.dynamic, dart.dynamic]],
      newJsList: [dart.dynamic, [dart.dynamic]],
      cloneNotRequired: [core.bool, [dart.dynamic]]
    })
  });
  class _AcceptStructuredCloneDart2Js extends _AcceptStructuredClone {
    _AcceptStructuredCloneDart2Js() {
      super._AcceptStructuredClone();
    }
    newJsList(length) {
      return new Array(length);
    }
    newDartList(length) {
      return this.newJsList(length);
    }
    identicalInJs(a, b) {
      return core.identical(a, b);
    }
    forEachJsField(object, action) {
      for (let key of dart.as(Object.keys(object), core.Iterable)) {
        dart.dcall(action, key, object[key]);
      }
    }
  }
  dart.setSignature(_AcceptStructuredCloneDart2Js, {
    methods: () => ({
      newJsList: [dart.dynamic, [dart.dynamic]],
      newDartList: [dart.dynamic, [dart.dynamic]],
      identicalInJs: [core.bool, [dart.dynamic, dart.dynamic]],
      forEachJsField: [dart.void, [dart.dynamic, dart.dynamic]]
    })
  });
  function isJavaScriptDate(value) {
    return value instanceof Date;
  }
  dart.fn(isJavaScriptDate, core.bool, [dart.dynamic]);
  function isJavaScriptRegExp(value) {
    return value instanceof RegExp;
  }
  dart.fn(isJavaScriptRegExp, core.bool, [dart.dynamic]);
  function isJavaScriptArray(value) {
    return value instanceof Array;
  }
  dart.fn(isJavaScriptArray, core.bool, [dart.dynamic]);
  function isJavaScriptSimpleObject(value) {
    let proto = Object.getPrototypeOf(value);
    return proto === Object.prototype || proto === null;
  }
  dart.fn(isJavaScriptSimpleObject, core.bool, [dart.dynamic]);
  function isImmutableJavaScriptArray(value) {
    return !!value.immutable$list;
  }
  dart.fn(isImmutableJavaScriptArray, core.bool, [dart.dynamic]);
  function isJavaScriptPromise(value) {
    return typeof Promise != "undefined" && value instanceof Promise;
  }
  dart.fn(isJavaScriptPromise, core.bool, [dart.dynamic]);
  function convertNativePromiseToDartFuture(promise) {
    let completer = async.Completer.new();
    let then = dart.dcall(/* Unimplemented unknown name */convertDartClosureToJS, dart.fn(result => completer.complete(result), dart.void, [dart.dynamic]), 1);
    let error = dart.dcall(/* Unimplemented unknown name */convertDartClosureToJS, dart.fn(result => completer.completeError(result), dart.void, [dart.dynamic]), 1);
    let newPromise = promise.then(then).catch(error);
    return completer.future;
  }
  dart.fn(convertNativePromiseToDartFuture, async.Future, [dart.dynamic]);
  class Device extends core.Object {
    static get userAgent() {
      return dart.as(dart.dload(html.window.navigator.raw, 'userAgent'), core.String);
    }
    static get isOpera() {
      if (Device._isOpera == null) {
        Device._isOpera = Device.userAgent[dartx.contains]("Opera", 0);
      }
      return Device._isOpera;
    }
    static get isIE() {
      if (Device._isIE == null) {
        Device._isIE = !dart.notNull(Device.isOpera) && dart.notNull(Device.userAgent[dartx.contains]("Trident/", 0));
      }
      return Device._isIE;
    }
    static get isFirefox() {
      if (Device._isFirefox == null) {
        Device._isFirefox = Device.userAgent[dartx.contains]("Firefox", 0);
      }
      return Device._isFirefox;
    }
    static get isWebKit() {
      if (Device._isWebKit == null) {
        Device._isWebKit = !dart.notNull(Device.isOpera) && dart.notNull(Device.userAgent[dartx.contains]("WebKit", 0));
      }
      return Device._isWebKit;
    }
    static get cssPrefix() {
      let prefix = Device._cachedCssPrefix;
      if (prefix != null) return prefix;
      if (dart.notNull(Device.isFirefox)) {
        prefix = '-moz-';
      } else if (dart.notNull(Device.isIE)) {
        prefix = '-ms-';
      } else if (dart.notNull(Device.isOpera)) {
        prefix = '-o-';
      } else {
        prefix = '-webkit-';
      }
      return Device._cachedCssPrefix = prefix;
    }
    static get propertyPrefix() {
      let prefix = Device._cachedPropertyPrefix;
      if (prefix != null) return prefix;
      if (dart.notNull(Device.isFirefox)) {
        prefix = 'moz';
      } else if (dart.notNull(Device.isIE)) {
        prefix = 'ms';
      } else if (dart.notNull(Device.isOpera)) {
        prefix = 'o';
      } else {
        prefix = 'webkit';
      }
      return Device._cachedPropertyPrefix = prefix;
    }
    static isEventTypeSupported(eventType) {
      try {
        let e = html.Event.eventType(eventType, '');
        return dart.is(e, html.Event);
      } catch (_) {
      }

      return false;
    }
  }
  dart.setSignature(Device, {
    statics: () => ({isEventTypeSupported: [core.bool, [core.String]]}),
    names: ['isEventTypeSupported']
  });
  Device._isOpera = null;
  Device._isIE = null;
  Device._isFirefox = null;
  Device._isWebKit = null;
  Device._cachedCssPrefix = null;
  Device._cachedPropertyPrefix = null;
  const _childNodes = Symbol('_childNodes');
  const _node = Symbol('_node');
  const _iterable = Symbol('_iterable');
  const _filtered = Symbol('_filtered');
  class FilteredElementList extends collection.ListBase$(html.Element) {
    FilteredElementList(node) {
      this[_childNodes] = node.nodes;
      this[_node] = node;
    }
    get [_iterable]() {
      return new (_internal.WhereIterable$(html.Element))(this[_childNodes], dart.fn(n => dart.is(n, html.Element), core.bool, [html.Element]));
    }
    get [_filtered]() {
      return core.List$(html.Element).from(this[_iterable], {growable: false});
    }
    forEach(f) {
      this[_filtered][dartx.forEach](f);
    }
    set(index, value) {
      this.get(index).replaceWith(value);
      return value;
    }
    set length(newLength) {
      let len = this.length;
      if (dart.notNull(newLength) >= dart.notNull(len)) {
        return;
      } else if (dart.notNull(newLength) < 0) {
        dart.throw(new core.ArgumentError("Invalid list length"));
      }
      this.removeRange(newLength, len);
    }
    add(value) {
      this[_childNodes][dartx.add](value);
    }
    addAll(iterable) {
      for (let element of iterable) {
        this.add(element);
      }
    }
    contains(needle) {
      if (!dart.is(needle, html.Element)) return false;
      let element = dart.as(needle, html.Element);
      return dart.equals(element.parentNode, this[_node]);
    }
    get reversed() {
      return this[_filtered][dartx.reversed];
    }
    sort(compare) {
      if (compare === void 0) compare = null;
      dart.throw(new core.UnsupportedError('Cannot sort filtered list'));
    }
    setRange(start, end, iterable, skipCount) {
      if (skipCount === void 0) skipCount = 0;
      dart.throw(new core.UnsupportedError('Cannot setRange on filtered list'));
    }
    fillRange(start, end, fillValue) {
      if (fillValue === void 0) fillValue = null;
      dart.throw(new core.UnsupportedError('Cannot fillRange on filtered list'));
    }
    replaceRange(start, end, iterable) {
      dart.throw(new core.UnsupportedError('Cannot replaceRange on filtered list'));
    }
    removeRange(start, end) {
      core.List.from(this[_iterable][dartx.skip](start)[dartx.take](dart.notNull(end) - dart.notNull(start)))[dartx.forEach](dart.fn(el => dart.dsend(el, 'remove'), dart.void, [dart.dynamic]));
    }
    clear() {
      this[_childNodes][dartx.clear]();
    }
    removeLast() {
      let result = this[_iterable][dartx.last];
      if (result != null) {
        result.remove();
      }
      return result;
    }
    insert(index, value) {
      if (index == this.length) {
        this.add(value);
      } else {
        let element = this[_iterable][dartx.elementAt](index);
        element.parentNode.insertBefore(value, element);
      }
    }
    insertAll(index, iterable) {
      if (index == this.length) {
        this.addAll(iterable);
      } else {
        let element = this[_iterable][dartx.elementAt](index);
        element.parentNode.insertAllBefore(iterable, element);
      }
    }
    removeAt(index) {
      let result = this.get(index);
      result.remove();
      return result;
    }
    remove(element) {
      if (!dart.is(element, html.Element)) return false;
      if (dart.notNull(this.contains(element))) {
        dart.as(element, html.Element).remove();
        return true;
      } else {
        return false;
      }
    }
    get length() {
      return this[_iterable][dartx.length];
    }
    get(index) {
      return this[_iterable][dartx.elementAt](index);
    }
    get iterator() {
      return this[_filtered][dartx.iterator];
    }
    get rawList() {
      return this[_node].childNodes;
    }
  }
  FilteredElementList[dart.implements] = () => [NodeListWrapper];
  dart.setSignature(FilteredElementList, {
    constructors: () => ({FilteredElementList: [FilteredElementList, [html.Node]]}),
    methods: () => ({
      forEach: [dart.void, [dart.functionType(dart.void, [html.Element])]],
      set: [dart.void, [core.int, html.Element]],
      add: [dart.void, [html.Element]],
      addAll: [dart.void, [core.Iterable$(html.Element)]],
      sort: [dart.void, [], [dart.functionType(core.int, [html.Element, html.Element])]],
      setRange: [dart.void, [core.int, core.int, core.Iterable$(html.Element)], [core.int]],
      fillRange: [dart.void, [core.int, core.int], [html.Element]],
      replaceRange: [dart.void, [core.int, core.int, core.Iterable$(html.Element)]],
      removeLast: [html.Element, []],
      insert: [dart.void, [core.int, html.Element]],
      insertAll: [dart.void, [core.int, core.Iterable$(html.Element)]],
      removeAt: [html.Element, [core.int]],
      get: [html.Element, [core.int]]
    })
  });
  dart.defineExtensionMembers(FilteredElementList, [
    'forEach',
    'set',
    'add',
    'addAll',
    'contains',
    'sort',
    'setRange',
    'fillRange',
    'replaceRange',
    'removeRange',
    'clear',
    'removeLast',
    'insert',
    'insertAll',
    'removeAt',
    'remove',
    'get',
    'length',
    'reversed',
    'length',
    'iterator'
  ]);
  class Lists extends core.Object {
    static indexOf(a, element, startIndex, endIndex) {
      if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
        return -1;
      }
      if (dart.notNull(startIndex) < 0) {
        startIndex = 0;
      }
      for (let i = startIndex; dart.notNull(i) < dart.notNull(endIndex); i = dart.notNull(i) + 1) {
        if (dart.equals(a[dartx.get](i), element)) {
          return i;
        }
      }
      return -1;
    }
    static lastIndexOf(a, element, startIndex) {
      if (dart.notNull(startIndex) < 0) {
        return -1;
      }
      if (dart.notNull(startIndex) >= dart.notNull(a[dartx.length])) {
        startIndex = dart.notNull(a[dartx.length]) - 1;
      }
      for (let i = startIndex; dart.notNull(i) >= 0; i = dart.notNull(i) - 1) {
        if (dart.equals(a[dartx.get](i), element)) {
          return i;
        }
      }
      return -1;
    }
    static getRange(a, start, end, accumulator) {
      if (dart.notNull(start) < 0) dart.throw(new core.RangeError.value(start));
      if (dart.notNull(end) < dart.notNull(start)) dart.throw(new core.RangeError.value(end));
      if (dart.notNull(end) > dart.notNull(a[dartx.length])) dart.throw(new core.RangeError.value(end));
      for (let i = start; dart.notNull(i) < dart.notNull(end); i = dart.notNull(i) + 1) {
        accumulator[dartx.add](a[dartx.get](i));
      }
      return accumulator;
    }
  }
  dart.setSignature(Lists, {
    statics: () => ({
      indexOf: [core.int, [core.List, core.Object, core.int, core.int]],
      lastIndexOf: [core.int, [core.List, core.Object, core.int]],
      getRange: [core.List, [core.List, core.int, core.int, core.List]]
    }),
    names: ['indexOf', 'lastIndexOf', 'getRange']
  });
  class NodeListWrapper extends core.Object {}
  // Exports:
  exports.CssClassSetImpl = CssClassSetImpl;
  exports.convertDartToNative_SerializedScriptValue = convertDartToNative_SerializedScriptValue;
  exports.convertNativeToDart_SerializedScriptValue = convertNativeToDart_SerializedScriptValue;
  exports.convertNativeToDart_ContextAttributes = convertNativeToDart_ContextAttributes;
  exports.convertNativeToDart_ImageData = convertNativeToDart_ImageData;
  exports.convertDartToNative_ImageData = convertDartToNative_ImageData;
  exports.annotation_Creates_SerializedScriptValue = annotation_Creates_SerializedScriptValue;
  exports.annotation_Returns_SerializedScriptValue = annotation_Returns_SerializedScriptValue;
  exports.convertNativeToDart_Dictionary = convertNativeToDart_Dictionary;
  exports.convertDartToNative_Dictionary = convertDartToNative_Dictionary;
  exports.convertDartToNative_StringArray = convertDartToNative_StringArray;
  exports.convertNativeToDart_DateTime = convertNativeToDart_DateTime;
  exports.convertDartToNative_DateTime = convertDartToNative_DateTime;
  exports.convertDartToNative_PrepareForStructuredClone = convertDartToNative_PrepareForStructuredClone;
  exports.convertNativeToDart_AcceptStructuredClone = convertNativeToDart_AcceptStructuredClone;
  exports.isJavaScriptDate = isJavaScriptDate;
  exports.isJavaScriptRegExp = isJavaScriptRegExp;
  exports.isJavaScriptArray = isJavaScriptArray;
  exports.isJavaScriptSimpleObject = isJavaScriptSimpleObject;
  exports.isImmutableJavaScriptArray = isImmutableJavaScriptArray;
  exports.isJavaScriptPromise = isJavaScriptPromise;
  exports.convertNativePromiseToDartFuture = convertNativePromiseToDartFuture;
  exports.Device = Device;
  exports.FilteredElementList = FilteredElementList;
  exports.Lists = Lists;
  exports.NodeListWrapper = NodeListWrapper;
});