Work in progress.
diff --git a/pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart b/pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart
index 5e4f345..3deb927 100644
--- a/pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/abstract_scanner.dart
@@ -186,10 +186,10 @@
   void appendGtGt(PrecedenceInfo info);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
-  void appendComment(start, PrecedenceInfo info, bool asciiOnly);
+  void appendComment(int start, PrecedenceInfo info, bool asciiOnly);
 
   /** Documentation in subclass [ArrayBasedScanner]. */
-  void appendDartDoc(start, PrecedenceInfo info, bool asciiOnly);
+  void appendDartDoc(int start, PrecedenceInfo info, bool asciiOnly);
 
   /// Append [token] to the token stream.
   void appendErrorToken(ErrorToken token);
@@ -1134,7 +1134,7 @@
 
   LineStarts(int numberOfBytesHint) {
     // Let's assume the average Dart file is 300 bytes.
-    if (numberOfBytesHint == null) numberOfBytesHint = 300;
+    if (numberOfBytesHint == 0) numberOfBytesHint = 300;
 
     // Let's assume we have on average 22 bytes per line.
     final int expectedNumberOfLines = 1 + (numberOfBytesHint ~/ 22);
diff --git a/pkg/front_end/lib/src/fasta/scanner/array_based_scanner.dart b/pkg/front_end/lib/src/fasta/scanner/array_based_scanner.dart
index 3affe47..3e2169a 100644
--- a/pkg/front_end/lib/src/fasta/scanner/array_based_scanner.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/array_based_scanner.dart
@@ -231,13 +231,13 @@
     }
   }
 
-  void appendComment(start, PrecedenceInfo info, bool asciiOnly) {
+  void appendComment(int start, PrecedenceInfo info, bool asciiOnly) {
     if (!includeComments) return;
     Token newComment = createCommentToken(info, start, asciiOnly);
     _appendToCommentStream(newComment);
   }
 
-  void appendDartDoc(start, PrecedenceInfo info, bool asciiOnly) {
+  void appendDartDoc(int start, PrecedenceInfo info, bool asciiOnly) {
     if (!includeComments) return;
     Token newComment = createDartDocToken(info, start, asciiOnly);
     _appendToCommentStream(newComment);
diff --git a/pkg/front_end/lib/src/fasta/scanner/error_token.dart b/pkg/front_end/lib/src/fasta/scanner/error_token.dart
index cb03154..9e5700c 100644
--- a/pkg/front_end/lib/src/fasta/scanner/error_token.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/error_token.dart
@@ -81,11 +81,11 @@
 
   FastaCode get errorCode;
 
-  int get character => null;
+  int get character => -1;
 
   String get start => null;
 
-  int get endOffset => null;
+  int get endOffset => -1;
 
   BeginGroupToken get begin => null;
 
diff --git a/pkg/front_end/lib/src/fasta/scanner/precedence.dart b/pkg/front_end/lib/src/fasta/scanner/precedence.dart
index 40f96e9..9f87cd6 100644
--- a/pkg/front_end/lib/src/fasta/scanner/precedence.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/precedence.dart
@@ -18,7 +18,7 @@
   const PrecedenceInfo(this.value, this.name, this.precedence, this.kind,
       {this.isOperator: false, this.isUserDefinableOperator: false});
 
-  toString() => 'PrecedenceInfo($value, $precedence, $kind)';
+  String toString() => 'PrecedenceInfo($value, $precedence, $kind)';
 
   static const List<PrecedenceInfo> all = const <PrecedenceInfo>[
     BACKPING_INFO,
diff --git a/pkg/front_end/lib/src/fasta/scanner/recover.dart b/pkg/front_end/lib/src/fasta/scanner/recover.dart
index 33e79ba..4e005cd 100644
--- a/pkg/front_end/lib/src/fasta/scanner/recover.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/recover.dart
@@ -63,7 +63,7 @@
   /// [goodTail], that is, `beforeGoodTail.next == goodTail`.
   Token beforeGoodTail;
 
-  recoverIdentifier(NonAsciiIdentifierToken first) {
+  Token recoverIdentifier(NonAsciiIdentifierToken first) {
     List<int> codeUnits = <int>[];
 
     // True if the previous good token is an identifier and ends right where
@@ -102,7 +102,7 @@
     NonAsciiIdentifierToken current = first;
     while (current != errorTail) {
       codeUnits.add(current.character);
-      current = current.next;
+      current = current.next as NonAsciiIdentifierToken;
     }
     codeUnits.add(errorTail.character);
     int charOffset = first.charOffset;
@@ -127,32 +127,32 @@
       ..next = next;
   }
 
-  recoverExponent() {
+  Token recoverExponent() {
     return synthesizeToken(errorTail.charOffset, "NaN", Precedence.DOUBLE_INFO)
       ..next = errorTail.next;
   }
 
-  recoverString() {
+  Token recoverString() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
   }
 
-  recoverHexDigit() {
+  Token recoverHexDigit() {
     return synthesizeToken(errorTail.charOffset, "-1", Precedence.INT_INFO)
       ..next = errorTail.next;
   }
 
-  recoverStringInterpolation() {
+  Token recoverStringInterpolation() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
   }
 
-  recoverComment() {
+  Token recoverComment() {
     // TODO(ahe): Improve this.
     return skipToEof(errorTail);
   }
 
-  recoverUnmatched() {
+  Token recoverUnmatched() {
     // TODO(ahe): Try to use top-level keywords (such as `class`, `typedef`,
     // and `enum`) and identation to recover.
     return errorTail.next;
@@ -160,20 +160,20 @@
 
   for (Token current = tokens; !current.isEof; current = current.next) {
     if (current is ErrorToken) {
-      ErrorToken first = current;
+      ErrorToken first = current as ErrorToken;
       Token next = current;
       bool treatAsWhitespace = false;
       do {
         current = next;
         if (errorTail == null) {
-          error = next;
+          error = next as ErrorToken;
         } else {
           errorTail.next = next;
           next.previousToken = errorTail;
         }
-        errorTail = next;
+        errorTail = next as ErrorToken;
         next = next.next;
-      } while (next is ErrorToken && first.errorCode == next.errorCode);
+      } while (next is ErrorToken && first.errorCode == (next as ErrorToken).errorCode);
 
       FastaCode code = first.errorCode;
       if (code == codeEncoding ||
diff --git a/pkg/front_end/lib/src/fasta/scanner/string_canonicalizer.dart b/pkg/front_end/lib/src/fasta/scanner/string_canonicalizer.dart
index 0f452ab..b50f5852 100644
--- a/pkg/front_end/lib/src/fasta/scanner/string_canonicalizer.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/string_canonicalizer.dart
@@ -7,7 +7,7 @@
 import 'dart:convert';
 
 class Node {
-  var /* String | List<int> */ data;
+  Object /* String | List<int> */ data;
   int start;
   int end;
   String payload;
@@ -37,7 +37,7 @@
   List<Node> _nodes = new List<Node>(INITIAL_SIZE);
 
   static String decode(List<int> data, int start, int end, bool asciiOnly) {
-    var s;
+    String s;
     if (asciiOnly) {
       s = new String.fromCharCodes(data, start, end);
     } else {
@@ -82,11 +82,9 @@
     _nodes = newNodes;
   }
 
-  String canonicalize(data, int start, int end, bool asciiOnly) {
+  String _canonicalizeString(String data, int start, int end, bool asciiOnly) {
     if (_count > _size) rehash();
-    int index = data is String
-        ? hashString(data, start, end)
-        : hashBytes(data, start, end);
+    int index = hashString(data as String, start, end);
     index = index & (_size - 1);
     Node s = _nodes[index];
     Node t = s;
@@ -94,7 +92,7 @@
     while (t != null) {
       if (t.end - t.start == len) {
         int i = start, j = t.start;
-        while (i < end && data[i] == t.data[j]) {
+        while (i < end && data[i] == (t.data as String)[j]) {
           i++;
           j++;
         }
@@ -104,16 +102,50 @@
       }
       t = t.next;
     }
-    String payload;
-    if (data is String)
-      payload = data.substring(start, end);
-    else
-      payload = decode(data, start, end, asciiOnly);
+    String payload = data.substring(start, end);
     _nodes[index] = new Node(data, start, end, payload, s);
     _count++;
     return payload;
   }
 
+
+  String _canonicalizeBytes(List<int> data, int start, int end, bool asciiOnly) {
+    if (_count > _size) rehash();
+    int index = hashBytes(data as List<int>, start, end);
+    index = index & (_size - 1);
+    Node s = _nodes[index];
+    Node t = s;
+    int len = end - start;
+    while (t != null) {
+      if (t.end - t.start == len) {
+        int i = start, j = t.start;
+        while (i < end && data[i] == (t.data as List<int>)[j]) {
+          i++;
+          j++;
+        }
+        if (i == end) {
+          return t.payload;
+        }
+      }
+      t = t.next;
+    }
+    String payload = decode(data, start, end, asciiOnly);
+    _nodes[index] = new Node(data, start, end, payload, s);
+    _count++;
+    return payload;
+  }
+
+
+
+  String canonicalize(Object data, int start, int end, bool asciiOnly) {
+    if (data is String) {
+      return _canonicalizeString(data, start, end, asciiOnly);
+    } else {
+      assert(data is List<int>);
+      return _canonicalizeBytes(data, start, end, asciiOnly);
+    }
+  }
+
   clear() {
     _nodes = new List<Node>(_size);
   }
diff --git a/pkg/front_end/lib/src/fasta/scanner/token.dart b/pkg/front_end/lib/src/fasta/scanner/token.dart
index d72cf9b..698e441 100644
--- a/pkg/front_end/lib/src/fasta/scanner/token.dart
+++ b/pkg/front_end/lib/src/fasta/scanner/token.dart
@@ -366,7 +366,7 @@
    */
   static const int LAZY_THRESHOLD = 4;
 
-  var /* String | LazySubtring */ valueOrLazySubstring;
+  Object /* String | LazySubtring */ valueOrLazySubstring;
 
   final PrecedenceInfo info;
 
@@ -417,21 +417,25 @@
       : super(charOffset);
 
   String get lexeme {
-    if (valueOrLazySubstring is String) {
-      return valueOrLazySubstring;
+    final currentValue = valueOrLazySubstring;
+    if (currentValue is String) {
+      return currentValue;
     } else {
-      assert(valueOrLazySubstring is LazySubstring);
-      var data = valueOrLazySubstring.data;
-      int start = valueOrLazySubstring.start;
-      int end = start + valueOrLazySubstring.length;
+      assert(currentValue is LazySubstring);
+      final data = currentValue.data;
+      int start = currentValue.start;
+      int end = start + currentValue.length;
+      String newValue;
       if (data is String) {
-        valueOrLazySubstring = canonicalizedString(
-            data, start, end, valueOrLazySubstring.boolValue);
+        newValue = canonicalizedString(
+            data, start, end, currentValue.boolValue);
       } else {
-        valueOrLazySubstring =
-            decodeUtf8(data, start, end, valueOrLazySubstring.boolValue);
+        assert(data is List<int>);
+        newValue =
+            decodeUtf8(data, start, end, currentValue.boolValue);
       }
-      return valueOrLazySubstring;
+      valueOrLazySubstring = newValue;
+      return newValue;
     }
   }
 
@@ -555,7 +559,7 @@
  */
 abstract class LazySubstring {
   /** The original data, either a string or a List<int> */
-  get data;
+  Object get data;
 
   int get start;
   int get length;
@@ -572,7 +576,7 @@
 
   LazySubstring.internal();
 
-  factory LazySubstring(data, int start, int length, bool b) {
+  factory LazySubstring(Object data, int start, int length, bool b) {
     // See comment on [CompactLazySubstring].
     if (start < 0x100000 && length < 0x200) {
       int fields = (start << 9);
@@ -594,7 +598,7 @@
  * The file html_dart2js.dart is currently around 1MB.
  */
 class CompactLazySubstring extends LazySubstring {
-  final data;
+  final Object data;
   final int fields;
 
   CompactLazySubstring(this.data, this.fields) : super.internal();
@@ -605,7 +609,7 @@
 }
 
 class FullLazySubstring extends LazySubstring {
-  final data;
+  final Object data;
   final int start;
   final int length;
   final bool boolValue;
diff --git a/pkg/front_end/lib/src/fasta/util/link.dart b/pkg/front_end/lib/src/fasta/util/link.dart
index 87d6b2a..92cd8b4 100644
--- a/pkg/front_end/lib/src/fasta/util/link.dart
+++ b/pkg/front_end/lib/src/fasta/util/link.dart
@@ -19,7 +19,7 @@
 
   Iterator<T> get iterator => new LinkIterator<T>(this);
 
-  void printOn(StringBuffer buffer, [separatedBy]) {}
+  void printOn(StringBuffer buffer, [String separatedBy]) {}
 
   List<T> toList({bool growable: true}) {
     List<T> result;
@@ -75,16 +75,18 @@
 
   void forEach(void f(T element)) {}
 
-  bool operator ==(other) {
-    if (other is! Link<T>) return false;
-    return other.isEmpty;
+  bool operator ==(Object other) {
+    return other is Link<T> && other.isEmpty;
   }
 
-  int get hashCode => throw new UnsupportedError('Link.hashCode');
+  int get hashCode {
+    throw new UnsupportedError('Link.hashCode');
+    return 0;
+  }
 
   String toString() => "[]";
 
-  get length {
+  int get length {
     throw new UnsupportedError('get:length');
   }
 
@@ -114,7 +116,7 @@
   /// Returns true if f returns true for all elements of this list.
   ///
   /// Returns true for the empty list.
-  bool every(bool f(T)) {
+  bool every(bool f(T e)) {
     for (Link<T> link = this; !link.isEmpty; link = link.tail) {
       if (!f(link.head)) return false;
     }
@@ -126,24 +128,24 @@
   //
   // Unsupported Iterable<T> methods.
   //
-  bool any(bool f(T e)) => _unsupported('any');
-  T elementAt(int i) => _unsupported('elementAt');
-  Iterable<K> expand<K>(Iterable<K> f(T e)) => _unsupported('expand');
-  T firstWhere(bool f(T e), {T orElse()}) => _unsupported('firstWhere');
+  bool any(bool f(T e)) { throw new UnsupportedError("any"); }
+  T elementAt(int i) { throw new UnsupportedError('elementAt'); }
+  Iterable<K> expand<K>(Iterable<K> f(T e)) { throw new UnsupportedError('expand'); }
+  T firstWhere(bool f(T e), {T orElse()}) { throw new UnsupportedError('firstWhere'); }
   K fold<K>(K initialValue, K combine(K value, T element)) {
-    return _unsupported('fold');
+    throw new UnsupportedError('fold');
   }
 
-  T get last => _unsupported('get:last');
-  T lastWhere(bool f(T e), {T orElse()}) => _unsupported('lastWhere');
-  String join([separator = '']) => _unsupported('join');
-  T reduce(T combine(T a, T b)) => _unsupported('reduce');
-  T singleWhere(bool f(T e)) => _unsupported('singleWhere');
-  Iterable<T> skipWhile(bool f(T e)) => _unsupported('skipWhile');
-  Iterable<T> take(int n) => _unsupported('take');
-  Iterable<T> takeWhile(bool f(T e)) => _unsupported('takeWhile');
-  Set<T> toSet() => _unsupported('toSet');
-  Iterable<T> where(bool f(T e)) => _unsupported('where');
+  T get last { throw new UnsupportedError('get:last'); }
+  T lastWhere(bool f(T e), {T orElse()}) { throw new UnsupportedError('lastWhere'); }
+  String join([String separator = '']) { throw new UnsupportedError('join'); }
+  T reduce(T combine(T a, T b)) { throw new UnsupportedError('reduce'); }
+  T singleWhere(bool f(T e)) { throw new UnsupportedError('singleWhere'); }
+  Iterable<T> skipWhile(bool f(T e)) { throw new UnsupportedError('skipWhile'); }
+  Iterable<T> take(int n) { throw new UnsupportedError('take'); }
+  Iterable<T> takeWhile(bool f(T e)) { throw new UnsupportedError('takeWhile'); }
+  Set<T> toSet() { throw new UnsupportedError('toSet'); }
+  Iterable<T> where(bool f(T e)) { throw new UnsupportedError('where'); }
 
   _unsupported(String method) => throw new UnsupportedError(method);
 }
diff --git a/pkg/front_end/lib/src/fasta/util/link_implementation.dart b/pkg/front_end/lib/src/fasta/util/link_implementation.dart
index cc74c01..cd9f6e4 100644
--- a/pkg/front_end/lib/src/fasta/util/link_implementation.dart
+++ b/pkg/front_end/lib/src/fasta/util/link_implementation.dart
@@ -65,16 +65,15 @@
   Link<T> tail;
 
   LinkEntry(this.head, [Link<T> tail])
-      : this.tail = ((tail == null) ? const Link() : tail);
+      : this.tail = ((tail == null) ? new Link<T>() : tail);
 
   Link<T> prepend(T element) {
     // TODO(ahe): Use new Link<T>, but this cost 8% performance on VM.
     return new LinkEntry<T>(element, this);
   }
 
-  void printOn(StringBuffer buffer, [separatedBy]) {
+  void printOn(StringBuffer buffer, [String separatedBy = '']) {
     buffer.write(head);
-    if (separatedBy == null) separatedBy = '';
     for (Link link = tail; link.isNotEmpty; link = link.tail) {
       buffer.write(separatedBy);
       buffer.write(link.head);
@@ -90,7 +89,7 @@
   }
 
   Link<T> reverse() {
-    Link<T> result = const Link();
+    Link<T> result = new Link<T>();
     for (Link<T> link = this; link.isNotEmpty; link = link.tail) {
       result = result.prepend(link.head);
     }
@@ -125,20 +124,21 @@
     }
   }
 
-  bool operator ==(other) {
+  bool operator ==(Object other) {
     if (other is! Link<T>) return false;
     Link<T> myElements = this;
-    while (myElements.isNotEmpty && other.isNotEmpty) {
-      if (myElements.head != other.head) {
+    Link<T> other_ = other;
+    while (myElements.isNotEmpty && other_.isNotEmpty) {
+      if (myElements.head != other_.head) {
         return false;
       }
       myElements = myElements.tail;
-      other = other.tail;
+      other_ = other_.tail;
     }
-    return myElements.isEmpty && other.isEmpty;
+    return myElements.isEmpty && other_.isEmpty;
   }
 
-  int get hashCode => throw new UnsupportedError('LinkEntry.hashCode');
+  int get hashCode { throw new UnsupportedError('LinkEntry.hashCode'); }
 
   int slowLength() {
     int length = 0;
@@ -167,7 +167,8 @@
 
   LinkBuilderImplementation();
 
-  Link<T> toLink([Link<T> tail = const Link()]) {
+  Link<T> toLink([Link<T> tail]) {
+    if (tail == null) tail = new Link<T>();
     if (head == null) return tail;
     lastLink.tail = tail;
     Link<T> link = head;
diff --git a/pkg/kernel/bin/transform.dart b/pkg/kernel/bin/transform.dart
index 8c8a244..d83d1da 100755
--- a/pkg/kernel/bin/transform.dart
+++ b/pkg/kernel/bin/transform.dart
@@ -15,6 +15,7 @@
 import 'package:kernel/transformations/method_call.dart' as method_call;
 import 'package:kernel/transformations/mixin_full_resolution.dart' as mix;
 import 'package:kernel/transformations/treeshaker.dart' as treeshaker;
+import 'package:kernel/transformations/vip_type_check.dart' as viptypecheck;
 import 'package:kernel/vm/native_effects.dart';
 import 'package:kernel/vm/roots.dart';
 import 'package:kernel/verifier.dart';
@@ -95,6 +96,9 @@
     case 'vipclosures':
       program = vipclosures.transformProgram(program);
       break;
+    case 'viptypecheck':
+      program = viptypecheck.transformProgram(program);
+      break;
     case 'treeshake':
       program = treeshaker.transformProgram(program,
           programRoots: programRoots..addAll(vmRoots),
diff --git a/pkg/kernel/lib/ast.dart b/pkg/kernel/lib/ast.dart
index 0112b5a..abab31b 100644
--- a/pkg/kernel/lib/ast.dart
+++ b/pkg/kernel/lib/ast.dart
@@ -1965,7 +1965,7 @@
     arguments?.parent = this;
   }
 
-  Procedure get interfaceTarget => interfaceTargetReference?.asProcedure;
+  Member get interfaceTarget => interfaceTargetReference?.asMember;
 
   void set interfaceTarget(Member target) {
     interfaceTargetReference = getMemberReference(target);
diff --git a/pkg/kernel/lib/clone.dart b/pkg/kernel/lib/clone.dart
index 7bd4f6d..2771bb4 100644
--- a/pkg/kernel/lib/clone.dart
+++ b/pkg/kernel/lib/clone.dart
@@ -6,6 +6,75 @@
 import 'ast.dart';
 import 'type_algebra.dart';
 
+
+typedef String Renamer(Class node);
+
+String _idRenamer(Class node) => node.name;
+
+class S extends DartTypeVisitor<DartType> {
+  final Map<TreeNode, TreeNode> mapping;
+
+  S(this.mapping);
+
+  DartType defaultDartType(DartType node) => node;
+
+  int changed = 0;
+
+  Class visitClass(Class node) {
+    if (mapping.containsKey(node)) {
+      changed++;
+      return mapping[node];
+    }
+    return node;
+  }
+
+  DartType visit(DartType node) => node.accept(this);
+
+  DartType visitInterfaceType(InterfaceType node) {
+    final oldChanged = changed;
+    final typeArguments = node.typeArguments.map(visit).toList();
+    final classNode = visitClass(node.classNode);
+    if (changed != oldChanged) {
+      changed++;
+      return new InterfaceType(classNode, typeArguments);
+    }
+    return node;
+  }
+
+  NamedType visitNamedType(NamedType type) {
+    final oldChanged = changed;
+    final DartType t = visit(type.type);
+    if (oldChanged != changed) {
+      return new NamedType(type.name, t);
+    } else {
+      return type;
+    }
+  }
+
+  Supertype visitSupertype(Supertype node) {
+    final oldChanged = changed;
+    final Class classNode = visitClass(node.classNode);
+    final List<DartType> typeArguments = node.typeArguments.map(visit).toList();
+    if (oldChanged != changed) {
+      return new Supertype(classNode, typeArguments);
+    }
+    return node;
+  }
+
+  DartType visitFunctionType(FunctionType node) {
+    final oldChanged = changed;
+    final List<TypeParameter> typeParameters = node.typeParameters;
+    final int requiredParameterCount = node.requiredParameterCount;
+    final List<DartType> positionalParameters = node.positionalParameters.map(visit).toList();
+    final List<NamedType> namedParameters = node.namedParameters.map(visitNamedType).toList();
+    final DartType returnType = visit(node.returnType);
+    if (oldChanged != changed) {
+      return new FunctionType(positionalParameters, returnType, requiredParameterCount: requiredParameterCount, namedParameters: namedParameters, typeParameters: typeParameters);
+    }
+    return node;
+  }
+}
+
 /// Visitor that return a clone of a tree, maintaining references to cloned
 /// objects.
 ///
@@ -18,8 +87,10 @@
       <LabeledStatement, LabeledStatement>{};
   final Map<SwitchCase, SwitchCase> switchCases = <SwitchCase, SwitchCase>{};
   final Map<TypeParameter, DartType> typeSubstitution;
+  final renamer;
 
-  CloneVisitor({Map<TypeParameter, DartType> typeSubstitution})
+  CloneVisitor({Map<TypeParameter, DartType> typeSubstitution,
+                this.renamer: _idRenamer})
       : this.typeSubstitution = ensureMutable(typeSubstitution);
 
   static Map<TypeParameter, DartType> ensureMutable(
@@ -31,12 +102,106 @@
     return map;
   }
 
+  TreeNode defaultTreeNode(TreeNode node) => throw "Cloning of ${node.runtimeType} is not implemented";
+
   TreeNode visitLibrary(Library node) {
     throw 'Cloning of libraries is not implemented';
   }
 
+  final Map<TreeNode, TreeNode> mapping = <TreeNode, TreeNode>{};
+
   TreeNode visitClass(Class node) {
-    throw 'Cloning of classes is not implemented';
+    final cloned = new Class(name: renamer(node),
+        isAbstract: node.isAbstract, fileUri: node.fileUri);
+    mapping[node] = cloned;
+
+    substituteSupertype(Supertype type) {
+      if (type != null) {
+        type = Substitution.fromMap(typeSubstitution)
+            .substituteSupertype(type);
+        type = new S(mapping).visitSupertype(type);
+      }
+      return type;
+    }
+
+    cloned.typeParameters.addAll(node.typeParameters.map((TypeParameter param) {
+      if (typeSubstitution.containsKey(param)) {
+        return null;
+      }
+
+      return visitTypeParameter(param);
+    }).where((p) => p != null));
+
+    cloned.supertype = substituteSupertype(node.supertype);
+    cloned.mixedInType = substituteSupertype(node.mixedInType);
+    cloned.implementedTypes.addAll(node.implementedTypes.map(substituteSupertype));
+
+    cloneConstructor(Constructor node) {
+      return mapping[node] = new Constructor(null,
+          name: node.name,
+          isConst: node.isConst,
+          isExternal: node.isExternal,
+          transformerFlags: node.transformerFlags)
+        ..fileEndOffset = node.fileEndOffset;
+    }
+
+    fillConstructor(Constructor node) {
+      final Constructor nodeClone = mapping[node];
+      nodeClone.function = clone(node.function);
+      nodeClone.function?.parent = nodeClone;
+      nodeClone.initializers = node.initializers.map(clone).toList();
+      setParents(nodeClone.initializers, nodeClone);
+    }
+
+    cloneProcedure(Procedure node) {
+      return mapping[node] = new Procedure(node.name, node.kind, null /* clone(node.function) */,
+          isAbstract: node.isAbstract,
+          isStatic: node.isStatic,
+          isExternal: node.isExternal,
+          isConst: node.isConst,
+          transformerFlags: node.transformerFlags,
+          fileUri: node.fileUri)..fileEndOffset = node.fileEndOffset;
+    }
+
+    fillProcedure(Procedure node) {
+      final Procedure nodeClone = mapping[node];
+      nodeClone.function = clone(node.function);
+      nodeClone.function?.parent = nodeClone;
+    }
+
+    cloneField(Field node) {
+      return mapping[node] = new Field(node.name,
+          type: visitType(node.type),
+          initializer: null/* cloneOptional(node.initializer) */,
+          isFinal: node.isFinal,
+          isConst: node.isConst,
+          isStatic: node.isStatic,
+          hasImplicitGetter: node.hasImplicitGetter,
+          hasImplicitSetter: node.hasImplicitSetter,
+          transformerFlags: node.transformerFlags,
+          fileUri: node.fileUri)..fileEndOffset = node.fileEndOffset;
+    }
+
+    fillField(Field node) {
+      final Field nodeClone = mapping[node];
+      nodeClone.initializer = cloneOptional(node.initializer);
+      nodeClone.initializer?.parent = nodeClone;
+    }
+
+    cloned.constructors.addAll(node.constructors.map(cloneConstructor));
+    setParents(cloned.constructors, cloned);
+
+    cloned.procedures.addAll(node.procedures.map(cloneProcedure));
+    setParents(cloned.procedures, cloned);
+
+    cloned.fields.addAll(node.fields.map(cloneField));
+    setParents(cloned.fields, cloned);
+
+    node.constructors.forEach(fillConstructor);
+    node.procedures.forEach(fillProcedure);
+    node.fields.forEach(fillField);
+
+    return cloned;
   }
 
   TreeNode clone(TreeNode node) =>
@@ -49,11 +214,11 @@
   }
 
   DartType visitType(DartType type) {
-    return substitute(type, typeSubstitution);
+    return new S(mapping).visit(substitute(type, typeSubstitution));
   }
 
   DartType visitOptionalType(DartType type) {
-    return type == null ? null : substitute(type, typeSubstitution);
+    return type == null ? null : visitType(type);
   }
 
   visitInvalidExpression(InvalidExpression node) => new InvalidExpression();
@@ -67,68 +232,85 @@
     return new VariableSet(variables[node.variable], clone(node.value));
   }
 
+  Member redirect(Member m) => m == null ? null : (mapping[m] ?? m);
+
   visitPropertyGet(PropertyGet node) {
-    return new PropertyGet.byReference(
-        clone(node.receiver), node.name, node.interfaceTargetReference);
+    return new PropertyGet(
+        clone(node.receiver), node.name, redirect(node.interfaceTarget));
   }
 
   visitPropertySet(PropertySet node) {
-    return new PropertySet.byReference(clone(node.receiver), node.name,
-        clone(node.value), node.interfaceTargetReference);
+    return new PropertySet(clone(node.receiver), node.name,
+        clone(node.value), redirect(node.interfaceTarget));
   }
 
   visitDirectPropertyGet(DirectPropertyGet node) {
-    return new DirectPropertyGet.byReference(
-        clone(node.receiver), node.targetReference);
+    return new DirectPropertyGet(
+        clone(node.receiver), redirect(node.target));
   }
 
   visitDirectPropertySet(DirectPropertySet node) {
-    return new DirectPropertySet.byReference(
-        clone(node.receiver), node.targetReference, clone(node.value));
+    return new DirectPropertySet(
+        clone(node.receiver), redirect(node.target), clone(node.value));
   }
 
   visitSuperPropertyGet(SuperPropertyGet node) {
-    return new SuperPropertyGet.byReference(
-        node.name, node.interfaceTargetReference);
+    return new SuperPropertyGet(
+        node.name, redirect(node.interfaceTarget));
   }
 
   visitSuperPropertySet(SuperPropertySet node) {
-    return new SuperPropertySet.byReference(
-        node.name, clone(node.value), node.interfaceTargetReference);
+    return new SuperPropertySet(
+        node.name, clone(node.value), redirect(node.interfaceTarget));
   }
 
   visitStaticGet(StaticGet node) {
-    return new StaticGet.byReference(node.targetReference);
+    return new StaticGet(redirect(node.target));
   }
 
   visitStaticSet(StaticSet node) {
-    return new StaticSet.byReference(node.targetReference, clone(node.value));
+    return new StaticSet(redirect(node.target), clone(node.value));
   }
 
   visitMethodInvocation(MethodInvocation node) {
-    return new MethodInvocation.byReference(clone(node.receiver), node.name,
-        clone(node.arguments), node.interfaceTargetReference);
+    return new MethodInvocation(clone(node.receiver), node.name,
+        clone(node.arguments), redirect(node.interfaceTarget));
   }
 
   visitDirectMethodInvocation(DirectMethodInvocation node) {
-    return new DirectMethodInvocation.byReference(
-        clone(node.receiver), node.targetReference, clone(node.arguments));
+    return new DirectMethodInvocation(
+        clone(node.receiver), redirect(node.target), clone(node.arguments));
   }
 
   visitSuperMethodInvocation(SuperMethodInvocation node) {
-    return new SuperMethodInvocation.byReference(
-        node.name, clone(node.arguments), node.interfaceTargetReference);
+    return new SuperMethodInvocation(
+        node.name, clone(node.arguments), redirect(node.interfaceTarget));
   }
 
   visitStaticInvocation(StaticInvocation node) {
-    return new StaticInvocation.byReference(
-        node.targetReference, clone(node.arguments),
+    return new StaticInvocation(
+        redirect(node.target), clone(node.arguments),
         isConst: node.isConst);
   }
 
   visitConstructorInvocation(ConstructorInvocation node) {
-    return new ConstructorInvocation.byReference(
-        node.targetReference, clone(node.arguments),
+    final target = redirect(node.target);
+    final Arguments arguments = clone(node.arguments);
+
+    final klass = node.target.enclosingClass;
+
+    if (target.enclosingClass.typeParameters.length != klass.typeParameters.length) {
+      var j = 0;
+      for (var i = 0; i < arguments.types.length; i++) {
+        if (!typeSubstitution.containsKey(klass.typeParameters[i])) {
+          arguments.types[j++] = arguments.types[i];
+        }
+      }
+      arguments.types.length = j;
+    }
+
+    return new ConstructorInvocation(
+        target, arguments,
         isConst: node.isConst);
   }
 
@@ -409,4 +591,12 @@
   visitNamedExpression(NamedExpression node) {
     return new NamedExpression(node.name, clone(node.value));
   }
+
+  visitFieldInitializer(FieldInitializer node) {
+    return new FieldInitializer(redirect(node.field), clone(node.value));
+  }
+
+  visitSuperInitializer(SuperInitializer node) {
+    return new SuperInitializer(redirect(node.target), visitArguments(node.arguments));
+  }
 }
diff --git a/pkg/kernel/lib/core_types.dart b/pkg/kernel/lib/core_types.dart
index 2d446fa..12e2789 100644
--- a/pkg/kernel/lib/core_types.dart
+++ b/pkg/kernel/lib/core_types.dart
@@ -20,6 +20,7 @@
   Class iterableClass;
   Class iteratorClass;
   Class futureClass;
+  Class futureOrClass;
   Class streamClass;
   Class symbolClass;
   Class internalSymbolClass;
@@ -50,6 +51,7 @@
     ],
     'dart:async': [
       'Future',
+      'FutureOr',
       'Stream',
     ]
   };
@@ -71,6 +73,7 @@
     functionClass = getClass('dart:core', 'Function');
     invocationClass = getClass('dart:core', 'Invocation');
     futureClass = getClass('dart:async', 'Future');
+    futureOrClass = getClass('dart:async', 'FutureOr');
     streamClass = getClass('dart:async', 'Stream');
     internalSymbolClass = getClass('dart:_internal', 'Symbol');
   }
diff --git a/pkg/kernel/lib/text/ast_to_text.dart b/pkg/kernel/lib/text/ast_to_text.dart
index 6858ed9..c9bfc40 100644
--- a/pkg/kernel/lib/text/ast_to_text.dart
+++ b/pkg/kernel/lib/text/ast_to_text.dart
@@ -99,6 +99,12 @@
   return '$buffer';
 }
 
+String debugNodeToStringX(Node node, Node highlight) {
+  StringBuffer buffer = new StringBuffer();
+  new Printer(buffer, syntheticNames: globalDebuggingNames, highlight: highlight).writeNode(node);
+  return '$buffer';
+}
+
 String programToString(Program node) {
   StringBuffer buffer = new StringBuffer();
   new Printer(buffer, syntheticNames: new NameSystem()).writeProgramFile(node);
@@ -170,6 +176,7 @@
   int column = 0;
   bool showExternal;
   bool showOffsets;
+  dynamic highlight;
 
   static int SPACE = 0;
   static int WORD = 1;
@@ -181,7 +188,8 @@
       this.showExternal,
       this.showOffsets: false,
       this.importTable,
-      this.annotator})
+      this.annotator,
+      this.highlight})
       : this.syntheticNames = syntheticNames ?? new NameSystem();
 
   Printer._inner(Printer parent, this.importTable)
@@ -380,10 +388,19 @@
     if (node == null) {
       writeSymbol("<Null>");
     } else {
+      if (node == highlight) {
+        sink.write("${kStart}");
+      }
+
       if (showOffsets && node is TreeNode) {
         writeWord("[${node.fileOffset}]");
       }
+
       node.accept(this);
+
+      if (node == highlight) {
+        sink.write("${kEnd}");
+      }
     }
   }
 
@@ -619,14 +636,26 @@
   }
 
   void writeVariableReference(VariableDeclaration variable) {
+    if (variable == highlight) {
+      sink.write("${kStart}");
+    }
     writeWord(getVariableReference(variable));
-  }
+    if (variable == highlight) {
+      sink.write("${kEnd}");
+    }
+ }
 
   void writeTypeParameterReference(TypeParameter node) {
     writeWord(getTypeParameterReference(node));
   }
 
+  static const kStart = "\u001b[1;31m";
+  static const kEnd = "\u001b[0;0m";
+
   void writeExpression(Expression node, [int minimumPrecedence]) {
+    if (node == highlight) {
+      sink.write("${kStart}");
+    }
     if (showOffsets) writeWord("[${node.fileOffset}]");
     bool needsParenteses = false;
     if (minimumPrecedence != null && getPrecedence(node) < minimumPrecedence) {
@@ -637,6 +666,9 @@
     if (needsParenteses) {
       writeSymbol(')');
     }
+    if (node == highlight) {
+      sink.write("${kEnd}");
+    }
   }
 
   void writeAnnotation(Expression node) {
diff --git a/pkg/kernel/lib/transformations/vip_type_check.dart b/pkg/kernel/lib/transformations/vip_type_check.dart
new file mode 100644
index 0000000..819b5fa
--- /dev/null
+++ b/pkg/kernel/lib/transformations/vip_type_check.dart
@@ -0,0 +1,547 @@
+// Copyright (c) 2017, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+library kernel.transformations.vip_type_check;
+
+import 'dart:io';
+
+import '../kernel.dart';
+import '../ast.dart';
+import '../core_types.dart';
+import '../type_algebra.dart';
+import '../type_checker.dart';
+import '../class_hierarchy.dart';
+import '../text/ast_to_text.dart';
+import '../clone.dart';
+
+Program transformProgram(Program program) {
+  try {
+    program.accept(new FactoryReturnTypeFixer());
+
+    new GenericInstantiator(program);
+
+    print(programToString(program));
+
+    new TypeChecker1(program).checkProgram(program);
+
+    return program;
+  } on TypeCheckFail catch (e) {
+    exit(-1);
+  }
+//  return program.accept(new TypeChecker());
+}
+
+int findFileOffset(TreeNode context) {
+  while (context != null && context.fileOffset == TreeNode.noOffset) {
+    context = context.parent;
+  }
+
+  return context?.fileOffset ?? TreeNode.noOffset;
+}
+
+void report(Program program, TreeNode where, String message) {
+  var context = where;
+  while (context is! Member) {
+    context = context.parent;
+  }
+
+  final fileOffset = findFileOffset(where);
+  if (fileOffset != TreeNode.noOffset) {
+    final fileUri = (context is Procedure || context is Field)
+        ? context.fileUri
+        : (context.enclosingClass ?? context.enclosingLibrary).fileUri;
+
+    var program = context.enclosingProgram;
+    var source = program.uriToSource[fileUri];
+    var location = program.getLocation(fileUri, fileOffset);
+    var lineStart = source.lineStarts[location.line - 1];
+    var lineEnd = (location.line < source.lineStarts.length)
+        ? source.lineStarts[location.line]
+        : (source.source.length - 1);
+    if (lineStart < source.source.length &&
+        lineEnd < source.source.length &&
+        lineStart < lineEnd) {
+      print("\nIn ${fileUri}:${location.line}\n");
+      print(
+          new String.fromCharCodes(source.source.getRange(lineStart, lineEnd)));
+      print("");
+    }
+  }
+  if (context is! Field) {
+    context = context.function;
+  }
+
+  var name = "", body = context;
+  if (context is FunctionNode) {
+    final parent = context.parent;
+
+    if (parent is Member) {
+      name = "${parent.parent.name}::${parent.name.name}";
+    } else if (parent is FunctionDeclaration) {
+      name = parent.variable.name;
+    } else {
+      name = "anonymous function";
+    }
+
+    body = context.body;
+  } else {
+    final field = context as Field;
+    name = "field initializer for ${field.parent}.${field.name}";
+  }
+
+  var host = "";
+
+  print('''
+In ${name}:
+
+    ${message}
+
+${debugNodeToStringX(body.parent.parent, where)}
+''');
+}
+
+class GenericInstantiator extends RecursiveVisitor {
+  final Program program;
+  final TypeKindAnalyzer typeKindAnalyzer;
+
+  CoreTypes get coreTypes => typeKindAnalyzer.coreTypes;
+
+  GenericInstantiator(this.program)
+      : typeKindAnalyzer = new TypeKindAnalyzer(program) {
+    processProgram();
+  }
+
+  void processProgram() {
+    for (var library in program.libraries) {
+      for (var class_ in library.classes.toList(growable: false)) {
+        if (class_.typeParameters.isNotEmpty) {
+          continue;
+        }
+
+        for (var constructor in class_.constructors) {
+          if (constructor.function.typeParameters.isNotEmpty) {
+            continue;
+          }
+
+          constructor.accept(this);
+        }
+
+        for (var procedure in class_.procedures) {
+          if (procedure.function.typeParameters.isNotEmpty) {
+            continue;
+          }
+
+          procedure.accept(this);
+        }
+
+        class_.fields.forEach((f) => f.accept(this));
+      }
+
+      for (var procedure in library.procedures) {
+        procedure.accept(this);
+      }
+
+      for (var field in library.fields) {
+        field.accept(this);
+      }
+    }
+  }
+
+  @override
+  visitConstructorInvocation(ConstructorInvocation node) {
+    final List<DartType> types = node.arguments.types;
+    if (types.isNotEmpty) {
+      final Class klass = node.target.enclosingClass;
+      final Class clone =
+          instantiate(klass, types.map((t) => typeKindAnalyzer.toTypeKind(t, where: node)).toList());
+      if (!identical(clone, klass)) {
+        final name = node.target.name;
+        final ctor = clone.constructors
+            .firstWhere((ctor) => ctor.name == node.target.name);
+        node.target = ctor;
+      }
+    }
+  }
+
+  final Set<Instantiation> insns = new Set<Instantiation>();
+  List<Instantiation> insnsWorklist = new List<Instantiation>();
+
+  Class instantiate(Class klass, List<TypeKind> types) {
+    final insn = new Instantiation(klass, types);
+    if (insns.add(insn)) {
+      print('Instantiating ${insn.klass} with ${insn.types}');
+      if (!insn.types.every((t) => t == TypeKind.Reference)) {
+        final orig = insn.klass;
+        final suffix = insn.types.map((t) {
+          switch (t) {
+            case TypeKind.Reference:
+              return "R";
+            case TypeKind.Double:
+              return "D";
+            case TypeKind.Integer:
+              return "I";
+          }
+        }).join('');
+
+        Map<TypeParameter, DartType> typeSubstitution =
+            <TypeParameter, DartType>{};
+        for (var i = 0; i < orig.typeParameters.length; i++) {
+          final param = orig.typeParameters[i];
+          final kind = insn.types[i];
+          switch (kind) {
+            case TypeKind.Reference:
+              break;
+            case TypeKind.Integer:
+              typeSubstitution[param] = coreTypes.intClass.rawType;
+              break;
+            case TypeKind.Double:
+              typeSubstitution[param] = coreTypes.doubleClass.rawType;
+              break;
+          }
+        }
+
+        final cloner = new CloneVisitor(
+            typeSubstitution: typeSubstitution,
+            renamer: (Class node) {
+              if (identical(node, orig)) {
+                return "${orig.name}%${suffix}";
+              }
+              return node.name;
+            });
+
+        final clone = cloner.visitClass(orig);
+        orig.enclosingLibrary.addClass(clone);
+        insn.node = clone;
+      } else {
+        insn.node = insn.klass;
+      }
+
+      insnsWorklist.add(insn);
+
+      return insn.klass;
+    } else {
+      return insns.lookup(insn).klass;
+    }
+  }
+
+  void drainWorklist(TypeCheckingVisitor visitor) {
+    while (insnsWorklist.isNotEmpty) {
+      final items = insnsWorklist;
+      insnsWorklist = new List<Instantiation>();
+
+      for (var insn in items) {
+        typeKindAnalyzer.substitution =
+            new Map<TypeParameter, TypeKind>.fromIterables(
+                insn.klass.typeParameters, insn.types);
+        insn.klass.accept(this);
+        typeKindAnalyzer.substitution = null;
+      }
+    }
+  }
+}
+
+class FactoryReturnTypeFixer extends RecursiveVisitor {
+  @override
+  void visitProcedure(Procedure proc) {
+    if (proc.isFactory && proc.function.returnType == const DynamicType()) {
+      final function = proc.function;
+      final host = proc.parent as Class;
+      assert(function.typeParameters.length == host.typeParameters.length);
+      function.returnType = new InterfaceType(
+          host,
+          function.typeParameters
+              .map((p) => new TypeParameterType(p))
+              .toList());
+    }
+  }
+}
+
+enum Assignable { Ok, Check, Fail }
+
+class TypeCheckFail {
+  final message;
+  TypeCheckFail(this.message);
+}
+
+class TypeKindAnalyzer {
+  final Program program;
+  final CoreTypes coreTypes;
+
+  final Class DoubleClass;
+  final Class SmiClass;
+
+  Map<TypeParameter, TypeKind> substitution;
+
+  TypeKindAnalyzer(Program program) : this._(program, new CoreTypes(program));
+
+  TypeKindAnalyzer._(this.program, this.coreTypes)
+      : DoubleClass = coreTypes.getClass('dart:core', '_Double'),
+        SmiClass = coreTypes.getClass('dart:core', '_Integer');
+
+  TypeKind toTypeKind(DartType type, {TreeNode where}) {
+    if (type is InterfaceType) {
+      final classNode = type.classNode;
+
+      if (classNode == coreTypes.numClass) {
+        throw "num type is forbiden";
+      }
+
+      if (classNode == coreTypes.intClass || classNode == SmiClass) {
+        return TypeKind.Integer;
+      } else if (classNode == coreTypes.doubleClass ||
+          classNode == DoubleClass) {
+        return TypeKind.Double;
+      } else {
+        return TypeKind.Reference;
+      }
+    } else if (type is FunctionType) {
+      return TypeKind.Reference;
+    } else if (type is BottomType) {
+      return TypeKind.Reference;
+    } else if (type is TypeParameterType &&
+        substitution?.containsKey(type.parameter) == true) {
+      return substitution[type.parameter];
+    } else {
+      report(program, where, "Can't establish whether ${type} is integer, double or reference");
+      throw "Can't establish whether ${type} is integer, double or reference";
+    }
+  }
+}
+
+class TypeChecker1 extends TypeChecker {
+  final Class DoubleClass;
+  final Class SmiClass;
+
+  TypeChecker1(Program program)
+      : this._(new CoreTypes(program), new ClassHierarchy(program));
+
+  TypeChecker1._(CoreTypes coreTypes, ClassHierarchy hierarchy)
+      : DoubleClass = coreTypes.getClass('dart:core', '_Double'),
+        SmiClass = coreTypes.getClass('dart:core', '_Integer'),
+        super(coreTypes, hierarchy);
+
+  TypeKind toTypeKind(TreeNode where, DartType type) {
+    if (type is InterfaceType) {
+      final classNode = type.classNode;
+
+      if (classNode == coreTypes.numClass) {
+        fail(where, "num type is forbiden");
+      }
+
+      if (classNode == coreTypes.intClass || classNode == SmiClass) {
+        return TypeKind.Integer;
+      } else if (classNode == coreTypes.doubleClass ||
+          classNode == DoubleClass) {
+        return TypeKind.Double;
+      } else {
+        return TypeKind.Reference;
+      }
+    } else if (type is FunctionType) {
+      return TypeKind.Reference;
+    } else if (type is BottomType) {
+      return TypeKind.Reference;
+    } else if (type is TypeParameterType &&
+        mapping.containsKey(type.parameter)) {
+      return mapping[type.parameter];
+    } else {
+      fail(where,
+          "Can't establish whether ${type} is integer, double or reference");
+    }
+  }
+
+  bool isInteger(DartType type) => toTypeKind(null, type) == TypeKind.Integer;
+
+  bool isDouble(DartType type) => toTypeKind(null, type) == TypeKind.Double;
+
+  bool isNumeric(DartType type) => toTypeKind(null, type) != TypeKind.Reference;
+
+  Assignable isAssignable(TreeNode where, DartType from, DartType to) {
+    if (to == const DynamicType()) {
+      fail(where, "Destination has type dynamic.");
+    }
+
+    if (from == const DynamicType()) {
+      fail(where, "Source expression has type dynamic");
+    }
+
+    if (from == to) {
+      return Assignable.Ok;
+    }
+
+    final fromKind = toTypeKind(where, from);
+    final toKind = toTypeKind(where, to);
+
+    if (fromKind != toKind) {
+      return Assignable.Fail;
+    }
+
+    if (fromKind == TypeKind.Reference) {
+      if (environment.isSubtypeOf(from, to)) {
+        return Assignable.Ok;
+      } else if (environment.isSubtypeOf(to, from)) {
+        return Assignable.Check;
+      } else {
+        return Assignable.Fail;
+      }
+    }
+
+    return Assignable.Ok;
+  }
+
+  /// Check that [from] is a subtype of [to].
+  ///
+  /// [where] is an AST node indicating roughly where the check is required.
+  void checkAssignable(TreeNode where, DartType from, DartType to) {
+    switch (isAssignable(where, from, to)) {
+      case Assignable.Fail:
+      case Assignable.Check:
+        fail(where, '${from} is not assignable to ${to}');
+        break;
+      case Assignable.Ok:
+        break;
+    }
+  }
+
+  Expression checkAndDowncastExpression(
+      Expression expression, DartType from, DartType to) {
+    if (expression.parent is Field &&
+        expression.parent.initializer == expression &&
+        expression is NullLiteral) {
+      switch (toTypeKind(expression, to)) {
+        case TypeKind.Integer:
+          return new IntLiteral(0);
+        case TypeKind.Double:
+          return new DoubleLiteral(0.0);
+        case TypeKind.Reference:
+          return expression;
+      }
+    }
+
+    switch (isAssignable(expression, from, to)) {
+      case Assignable.Ok:
+        return expression;
+
+      case Assignable.Check:
+        return new AsExpression(expression, to);
+
+      case Assignable.Fail:
+        fail(expression, '${from} is not assignable to ${to}');
+        return expression;
+    }
+  }
+
+  List<InterfaceType> expand(List<InterfaceType> l) {
+    while (true) {
+      final t = l.last;
+      final sup = t.classNode.supertype;
+      if (sup == null) {
+        break;
+      }
+      final sub = Substitution.fromInterfaceType(t);
+      l.add(sub.substituteType(sup.asInterfaceType));
+    }
+    return l;
+  }
+
+  DartType leastUpperBound(TreeNode where, DartType a, DartType b) {
+    if (a == b) {
+      return a;
+    } else if (environment.isSubtypeOf(a, b)) {
+      return b;
+    } else if (environment.isSubtypeOf(b, a)) {
+      return a;
+    } else {
+      if (a is InterfaceType && b is InterfaceType) {
+        final List<InterfaceType> aSupers = expand([a]);
+        final List<InterfaceType> bSupers = expand([b]);
+        if (aSupers.last == bSupers.last) {
+          InterfaceType lub = aSupers.last;
+          for (var i = aSupers.length - 2, j = bSupers.length - 2;
+              0 <= i && 0 <= j;
+              --i, --j) {
+            if (aSupers[i] == bSupers[j]) {
+              lub = aSupers[i];
+            } else {
+              break;
+            }
+          }
+          return lub;
+        }
+      }
+      fail(where, "Can't compute least-upper-bound of ${a} and ${b}");
+      return const BottomType();
+    }
+  }
+
+  static int findFileOffset(TreeNode context) {
+    while (context != null && context.fileOffset == TreeNode.noOffset) {
+      context = context.parent;
+    }
+
+    return context?.fileOffset ?? TreeNode.noOffset;
+  }
+
+  void fail(TreeNode where, String message) {
+    var context = where;
+    while (context is! Member) {
+      context = context.parent;
+    }
+
+    final fileOffset = findFileOffset(where);
+    if (fileOffset != TreeNode.noOffset) {
+      final fileUri = (context is Procedure || context is Field)
+          ? context.fileUri
+          : (context.enclosingClass ?? context.enclosingLibrary).fileUri;
+
+      var program = context.enclosingProgram;
+      var source = program.uriToSource[fileUri];
+      var location = program.getLocation(fileUri, fileOffset);
+      var lineStart = source.lineStarts[location.line - 1];
+      var lineEnd = (location.line < source.lineStarts.length)
+          ? source.lineStarts[location.line]
+          : (source.source.length - 1);
+      if (lineStart < source.source.length &&
+          lineEnd < source.source.length &&
+          lineStart < lineEnd) {
+        print("\nIn ${fileUri}:${location.line}\n");
+        print(new String.fromCharCodes(
+            source.source.getRange(lineStart, lineEnd)));
+        print("");
+      }
+    }
+    if (context is! Field) {
+      context = context.function;
+    }
+
+    var name = "", body = context;
+    if (context is FunctionNode) {
+      final parent = context.parent;
+
+      if (parent is Member) {
+        name = "${parent.parent.name}::${parent.name.name}";
+      } else if (parent is FunctionDeclaration) {
+        name = parent.variable.name;
+      } else {
+        name = "anonymous function";
+      }
+
+      body = context.body;
+    } else {
+      final field = context as Field;
+      name = "field initializer for ${field.parent}.${field.name}";
+    }
+
+    var host = "";
+
+    print('''
+In ${name}:
+
+    ${message}
+
+${debugNodeToStringX(body.parent.parent, where)}
+''');
+
+    throw new TypeCheckFail('FAIL AT ${where}: ${message}');
+  }
+}
diff --git a/pkg/kernel/lib/type_algebra.dart b/pkg/kernel/lib/type_algebra.dart
index c86f4d2..6d73078 100644
--- a/pkg/kernel/lib/type_algebra.dart
+++ b/pkg/kernel/lib/type_algebra.dart
@@ -542,7 +542,15 @@
     if (type1 is BottomType && type2 is BottomType) return true;
     if (type1 is VectorType && type2 is VectorType) return true;
     if (type1 is InterfaceType && type2 is InterfaceType) {
-      if (type1.classNode != type2.classNode) return _fail();
+      if (type1.classNode != type2.classNode) {
+        if (type1.classNode.name == 'FutureOr') {
+          return _unify(type1.typeArguments[0], type2);
+        } else if (type2.classNode.name == 'FutureOr') {
+          return _unify(type1, type2.typeArguments[0]);
+        }
+
+        return _fail();
+      }
       assert(type1.typeArguments.length == type2.typeArguments.length);
       for (int i = 0; i < type1.typeArguments.length; ++i) {
         if (!_unify(type1.typeArguments[i], type2.typeArguments[i])) {
diff --git a/pkg/kernel/lib/type_checker.dart b/pkg/kernel/lib/type_checker.dart
index 6c48a6d..872deb0 100644
--- a/pkg/kernel/lib/type_checker.dart
+++ b/pkg/kernel/lib/type_checker.dart
@@ -8,6 +8,43 @@
 import 'core_types.dart';
 import 'type_algebra.dart';
 import 'type_environment.dart';
+import 'clone.dart';
+
+enum TypeKind { Reference, Integer, Double }
+
+class Instantiation {
+  final Class klass;
+  final List<TypeKind> types;
+
+  Class node;
+
+  Instantiation(this.klass, this.types);
+
+  bool operator == (other) {
+    return other is Instantiation &&
+           this.klass == other.klass &&
+           _listEquals(this.types, other.types);
+  }
+
+  int get hashCode => klass.hashCode ^ _listHash(types);
+
+  static bool _listEquals(List<TypeKind> a, List<TypeKind> b) {
+    if (a.length != b.length) return false;
+    for (var i = 0; i < a.length; i++) {
+      if (a[i] != b[i]) return false;
+    }
+    return true;
+  }
+
+  static int _listHash(List<TypeKind> a) {
+    int result = a.length;
+    for (var i = 0; i < a.length; i++) {
+      result |= a[i].hashCode;
+    }
+    return result;
+  }
+
+}
 
 /// Performs strong-mode type checking on the kernel IR.
 ///
@@ -22,7 +59,93 @@
     environment = new TypeEnvironment(coreTypes, hierarchy);
   }
 
+  DartType ensureNoDynamic(DartType type) {
+    if (type == const DynamicType()) {
+      return environment.objectType;
+    } else if (type is InterfaceType && type.typeArguments.isNotEmpty) {
+      return new InterfaceType(type.classNode, type.typeArguments.map(ensureNoDynamic).toList());
+    } else if (type is FunctionType) {
+      return new FunctionType(type.positionalParameters.map(ensureNoDynamic).toList(), ensureNoDynamic(type.returnType),
+          namedParameters: type.namedParameters, typeParameters: type.typeParameters, requiredParameterCount: type.requiredParameterCount);
+    } else {
+      return type;
+    }
+  }
+
+  void checkSignature(FunctionNode node) {
+    for (VariableDeclaration v in node.positionalParameters) {
+      v.type = ensureNoDynamic(v.type);
+    }
+
+    for (VariableDeclaration v in node.namedParameters) {
+      v.type = ensureNoDynamic(v.type);
+    }
+
+    node.returnType = ensureNoDynamic(node.returnType);
+  }
+
+  List<Field> checkSignatures(Program program) {
+    final List<Field> dynamicFields = <Field>[];
+
+    handleField(Field field) {
+      if (field.type == const DynamicType()) {
+        if ((field.initializer == null || field.initializer is NullLiteral)) {
+          field.type = environment.objectType;
+        } else {
+          dynamicFields.add(field);
+        }
+      }
+    }
+
+    int processed = 0;
+    for (var library in program.libraries) {
+      processed++;
+      print(
+          'Processing ${library.importUri} (${processed} of ${program.libraries.length})');
+      int nclass = 0;
+      for (var class_ in library.classes) {
+        nclass++;
+        print('${nclass}/${library.classes.length}: ${class_}');
+        for (var constructor in class_.constructors) {
+          checkSignature(constructor.function);
+        }
+        for (var procedure in class_.procedures) {
+          checkSignature(procedure.function);
+        }
+
+        class_.fields.forEach(handleField);
+      }
+
+      for (var procedure in library.procedures) {
+        checkSignature(procedure.function);
+      }
+
+      library.fields.forEach(handleField);
+    }
+
+    return dynamicFields;
+  }
+
+  void checkClass(TypeCheckingVisitor visitor, Class klass) {
+    environment.thisType = klass.thisType;
+    for (var field in klass.fields) {
+      visitor.visitField(field);
+    }
+    for (var constructor in klass.constructors) {
+      visitor.visitConstructor(constructor);
+    }
+    for (var procedure in klass.procedures) {
+      if (procedure.function.typeParameters.isNotEmpty) {
+        print('Skipping ${procedure}');
+        continue;
+      }
+      visitor.visitProcedure(procedure);
+    }
+  }
+
   void checkProgram(Program program) {
+    final dynamicFields = checkSignatures(program);
+
     for (var library in program.libraries) {
       if (library.importUri.scheme == 'dart') continue;
       for (var class_ in library.classes) {
@@ -32,23 +155,62 @@
         });
       }
     }
+
     var visitor = new TypeCheckingVisitor(this, environment);
-    for (var library in program.libraries) {
-      if (library.importUri.scheme == 'dart') continue;
-      for (var class_ in library.classes) {
-        environment.thisType = class_.thisType;
-        for (var field in class_.fields) {
+    var worklist = dynamicFields;
+
+    var changed;
+    do {
+      var current = worklist;
+      worklist = <Field>[];
+      changed = false;
+      for (var field in current) {
+        final parent = field.parent;
+        if (parent is Class) {
+          environment.thisType = parent.thisType;
+        } else {
+          environment.thisType = null;
+        }
+        try {
           visitor.visitField(field);
+          changed = true;
+        } catch (e) {
+          worklist.add(field);
         }
-        for (var constructor in class_.constructors) {
-          visitor.visitConstructor(constructor);
+      }
+
+      if (!changed && worklist.isNotEmpty) {
+        throw "Haha";
+      }
+    } while (worklist.isNotEmpty);
+
+    for (var field in dynamicFields) {
+      if (field.type == const DynamicType()) {
+        fail(field, "Field has type dynamic");
+      }
+    }
+
+    var processed = 0;
+    for (var library in program.libraries) {
+      processed++;
+      print(
+          'Processing ${library.importUri} (${processed} of ${program.libraries.length})');
+      int nclass = 0;
+      for (var klass in library.classes) {
+        nclass++;
+        if (klass.typeParameters.isNotEmpty) {
+          print('Skipping ${klass}');
+          continue;
         }
-        for (var procedure in class_.procedures) {
-          visitor.visitProcedure(procedure);
-        }
+        print('${nclass}/${library.classes.length}: ${klass}');
+        checkClass(visitor, klass);
       }
       environment.thisType = null;
       for (var procedure in library.procedures) {
+        if (procedure.function.typeParameters.isNotEmpty) {
+          print('Skipping ${procedure}');
+          continue;
+        }
         visitor.visitProcedure(procedure);
       }
       for (var field in library.fields) {
@@ -97,8 +259,202 @@
 
   /// Indicates that type checking failed.
   void fail(TreeNode where, String message);
+
+  bool isNumeric(DartType type);
+
+  bool isInteger(DartType type);
+
+  bool isDouble(DartType type);
+
+  TypeKind toTypeKind(TreeNode where, DartType type);
+
+  DartType leastUpperBound(TreeNode where, DartType a, DartType b);
 }
 
+enum SelectorKind {
+  Method,
+  Getter,
+  Setter,
+}
+
+class Selector {
+  final SelectorKind kind;
+  final Name name;
+
+  Selector(this.kind, this.name);
+
+  factory Selector.fromProcedure(Procedure procedure) {
+    SelectorKind kind;
+    switch (procedure.kind) {
+      case ProcedureKind.Getter:
+        kind = SelectorKind.Getter;
+        break;
+      case ProcedureKind.Setter:
+        kind = SelectorKind.Setter;
+        break;
+      case ProcedureKind.Operator:
+      case ProcedureKind.Method:
+      case ProcedureKind.Factory:
+        kind = SelectorKind.Method;
+        break;
+    }
+    return new Selector(kind, procedure.name);
+  }
+
+  Selector get asGetter => new Selector(SelectorKind.Getter, name);
+
+  Selector get asMethod => new Selector(SelectorKind.Method, name);
+
+  Selector modifyKindToAccess(Member target) {
+    if (target is Procedure) {
+      if (kind == SelectorKind.Method && target.kind == ProcedureKind.Getter) {
+        return asGetter; // This is a call-though-getter.
+      } else if (kind == SelectorKind.Getter &&
+          target.kind == ProcedureKind.Method) {
+        return asMethod; // This is a tear-off.
+      }
+    } else if (target is Field) {
+      if (kind == SelectorKind.Method) {
+        return asGetter; // This is a call-though-field.
+      }
+    }
+    return this;
+  }
+
+  int get hashCode => kind.hashCode ^ name.hashCode;
+
+  bool operator ==(other) =>
+      other is Selector && other.kind == kind && other.name == name;
+
+  String toString() {
+    if (kind == SelectorKind.Getter) return 'get:${name}';
+    if (kind == SelectorKind.Setter) return 'set:${name}';
+    assert(kind == SelectorKind.Method);
+    return '$name';
+  }
+}
+
+class LookupCache {
+  final Map<Class, Map<Selector, Member>> lookupCache =
+      <Class, Map<Selector, Member>>{};
+
+  final Map<Class, Map<Selector, Member>> interfaceLookupCache =
+      <Class, Map<Selector, Member>>{};
+
+  Member lookupSelector(Class klass, Selector selector) {
+    return lookupCache
+        .putIfAbsent(klass, () => <Selector, Member>{})
+        .putIfAbsent(selector, () {
+      while (klass != null) {
+        for (final Member member in klass.members) {
+          if (member.name == selector.name) {
+            if (member is Field) {
+              // A field shadows getter/call and setter iff non-final/non-const.
+              if (selector.kind == SelectorKind.Method) {
+                ensureIsFunctionType(member.type, 'call-through-field usage');
+                return member;
+              }
+              if (selector.kind == SelectorKind.Getter) {
+                return member;
+              }
+              if (selector.kind == SelectorKind.Setter &&
+                  (!member.isFinal && !member.isConst)) {
+                return member;
+              }
+            } else if (member is Procedure) {
+              // A procedure shadows getter/call but not setter.
+              if (selector.kind == SelectorKind.Getter &&
+                  member.kind == ProcedureKind.Method) {
+                ensureProcedureCanBeTornOff(member);
+                return member;
+              }
+              if (selector.kind == SelectorKind.Getter &&
+                  member.kind == ProcedureKind.Getter) {
+                return member;
+              }
+              if (selector.kind == SelectorKind.Setter &&
+                  member.kind == ProcedureKind.Setter) {
+                return member;
+              }
+              if (selector.kind == SelectorKind.Method &&
+                  (member.kind == ProcedureKind.Method ||
+                      member.kind == ProcedureKind.Operator ||
+                      member.kind == ProcedureKind.Factory)) {
+                return member;
+              }
+              if (selector.kind == SelectorKind.Method &&
+                  (member.kind == ProcedureKind.Getter)) {
+                ensureIsFunctionType(
+                    member.function.returnType, 'call-through-field usage');
+                return member;
+              }
+            } else {
+              throw "UNREACHABLE";
+            }
+          }
+        }
+        klass = klass.superclass;
+      }
+      return null;
+    });
+  }
+
+  Member lookupInterfaceSelector(Class klass, Selector selector) {
+    return interfaceLookupCache
+        .putIfAbsent(klass, () => <Selector, Member>{})
+        .putIfAbsent(selector, () {
+      Member member = lookupSelector(klass, selector);
+      if (member != null) return member;
+
+      for (final Supertype superType in klass.implementedTypes) {
+        member = lookupInterfaceSelector(superType.classNode, selector);
+        if (member != null) return member;
+      }
+      return null;
+    });
+  }
+
+  void ensureProcedureCanBeTornOff(Procedure procedure) {
+    final FunctionNode function = procedure.function;
+    if (function.requiredParameterCount !=
+            function.positionalParameters.length ||
+        function.namedParameters.isNotEmpty) {
+      throw 'No tear-off support for functions with optional parameters!';
+    }
+  }
+
+  void ensureIsFunctionType(DartType type, String msg) {
+    if (type is! FunctionType) {
+      throw 'Expected a [FunctionType] for $msg but got "$type".';
+    }
+  }
+}
+
+class AssignmentFinder extends RecursiveVisitor {
+  final VariableDeclaration decl;
+
+  AssignmentFinder(this.decl);
+
+  bool found = false;
+
+  @override
+  void visitVariableSet(VariableSet node) {
+    if (node.variable == decl) {
+      found = true;
+    } else {
+      super.visitVariableSet(node);
+    }
+  }
+
+  static bool hasAssignmentsTo(VariableDeclaration decl, TreeNode node) {
+    final finder = new AssignmentFinder(decl);
+    node.accept(finder);
+    return finder.found;
+  }
+}
+
+
+
 class TypeCheckingVisitor
     implements
         ExpressionVisitor<DartType>,
@@ -119,6 +475,10 @@
   }
 
   Expression checkAndDowncastExpression(Expression from, DartType to) {
+    if (isUntypedLambda(from)) {
+      handleUntypedLambda(from, to, new Set<TypeParameter>());
+    }
+
     var parent = from.parent;
     var type = visitExpression(from);
     var result = checker.checkAndDowncastExpression(from, type, to);
@@ -126,6 +486,14 @@
     return result;
   }
 
+  Expression checkAndDowncastExpressionFrom(
+      Expression from, DartType fromType, DartType to) {
+    var parent = from.parent;
+    var result = checker.checkAndDowncastExpression(from, fromType, to);
+    result.parent = parent;
+    return result;
+  }
+
   void checkExpressionNoDowncast(Expression expression, DartType to) {
     checkAssignable(expression, visitExpression(expression), to);
   }
@@ -163,6 +531,15 @@
   }
 
   visitField(Field node) {
+    if (node.type == const DynamicType() && node.initializer == null) {
+      fail(node, "Field ${node} has dynamic type and no initializer");
+      return;
+    }
+
+    if (node.type == const DynamicType()) {
+      node.type = visitExpression(node.initializer);
+    }
+
     if (node.initializer != null) {
       node.initializer =
           checkAndDowncastExpression(node.initializer, node.type);
@@ -198,14 +575,41 @@
   void handleNestedFunctionNode(FunctionNode node) {
     var oldReturn = environment.returnType;
     var oldYield = environment.yieldType;
+    var oldCanInferReturnType = environment.canInferReturnType;
     environment.returnType = _getInternalReturnType(node);
     environment.yieldType = _getYieldType(node);
+    environment.canInferReturnType = node.parent is FunctionExpression &&
+        environment.returnType == const DynamicType();
     handleFunctionNode(node);
+    if (environment.canInferReturnType) {
+      if (environment.returnType != const DynamicType()) {
+        node.returnType = environment.returnType;
+      }
+    }
     environment.returnType = oldReturn;
     environment.yieldType = oldYield;
+    environment.canInferReturnType = oldCanInferReturnType;
+  }
+
+  void fixupInitializer(VariableDeclaration node) {
+    if (node.initializer is NullLiteral) {
+      switch (checker.toTypeKind(node, node.type)) {
+        case TypeKind.Integer:
+          node.initializer = new IntLiteral(0);
+          break;
+        case TypeKind.Double:
+          node.initializer = new DoubleLiteral(0.0);
+          break;
+        case TypeKind.Reference:
+          return;
+      }
+      node.initializer.parent = node;
+    }
   }
 
   void handleOptionalParameter(VariableDeclaration parameter) {
+    fixupInitializer(parameter);
+
     if (parameter.initializer != null) {
       // Default parameter values cannot be downcast.
       checkExpressionNoDowncast(parameter.initializer, parameter.type);
@@ -214,7 +618,12 @@
 
   Substitution getReceiverType(
       TreeNode access, Expression receiver, Member member) {
-    var type = visitExpression(receiver);
+    return getReceiverTypeImpl(
+        visitExpression(receiver), access, receiver, member);
+  }
+
+  Substitution getReceiverTypeImpl(
+      DartType type, TreeNode access, Expression receiver, Member member) {
     Class superclass = member.enclosingClass;
     if (superclass.supertype == null) {
       return Substitution.empty; // Members on Object are always accessible.
@@ -248,9 +657,136 @@
         hierarchy.getClassAsInstanceOf(currentClass, member.enclosingClass));
   }
 
+  static bool isUntypedLambda(TreeNode node) {
+    return node is FunctionExpression &&
+        node.function.functionType.positionalParameters
+            .any((t) => t == const DynamicType());
+  }
+
+  // If function expression has untyped parameters then it infers their type
+  // based on the expectedType which is expected to be a FunctionType.
+  handleUntypedLambda(FunctionExpression arg, DartType expectedType,
+      Set<TypeParameter> typeParameters) {
+    if (!(expectedType is FunctionType &&
+        expectedType.positionalParameters.length ==
+            arg.function.positionalParameters.length)) {
+      fail(arg,
+          'Expected ${expectedType}, got function expression with untyped parameters.');
+    }
+
+    for (var i = 0; i < arg.function.positionalParameters.length; i++) {
+      final param_ = arg.function.positionalParameters[i];
+      if (param_.type != const DynamicType()) continue;
+
+      final paramType_ = (expectedType as FunctionType).positionalParameters[i];
+
+      if (containsTypeVariable(paramType_, typeParameters)) {
+        fail(arg,
+            'Expected ${expectedType}, got function expression with untyped parameters.');
+      }
+
+      arg.function.positionalParameters[i].type = paramType_;
+      if (paramType_ == const DynamicType()) {
+        fail(arg, 'Failed to infer type for the parameter');
+      }
+    }
+  }
+
+  void tryInferTypeArguments(
+      FunctionNode function,
+      Substitution receiver,
+      Arguments arguments,
+      List<TypeParameter> typeParameters) {
+    // We need to infer type parameters.
+    final quantifiedVariables = new Set<TypeParameter>.from(typeParameters);
+    var foundMapping = <TypeParameter, DartType>{};
+    for (var i = 0; i < arguments.positional.length; i++) {
+      final param = function.positionalParameters[i];
+      final arg = arguments.positional[i];
+
+      final expectedType =
+          receiver.substituteType(param.type, contravariant: true);
+
+      if (isUntypedLambda(arg)) {
+        handleUntypedLambda(arg, expectedType, quantifiedVariables);
+      }
+
+      final gotType = visitExpression(arg);
+      DartType candidate = gotType;
+      if (expectedType is InterfaceType && candidate is InterfaceType) {
+        findInstanceOf(Class klass, InterfaceType type) {
+          while (type.classNode != klass) {
+            final sup = type.classNode.supertype;
+            if (sup == null) {
+              return null;
+            }
+
+            final sub = Substitution.fromInterfaceType(type);
+            if (sup.classNode != klass) {
+              for (var supi in type.classNode.implementedTypes) {
+                if (supi.classNode == klass) {
+                  return sub.substituteType(supi.asInterfaceType);
+                }
+              }
+
+              for (var supi in type.classNode.implementedTypes) {
+                final res = findInstanceOf(klass, supi.asInterfaceType);
+                if (res != null) {
+                  return res;
+                }
+              }
+            }
+
+            type = sub.substituteType(sup.asInterfaceType);
+          }
+          return type;
+        }
+
+        candidate = findInstanceOf(expectedType.classNode, candidate as InterfaceType) ?? candidate;
+      }
+
+      var mapping = unifyTypes(expectedType, candidate, quantifiedVariables);
+      if (mapping != null) {
+        mapping.forEach((p, t1) {
+          final t2 = foundMapping[p];
+          if (t2 == null) {
+            foundMapping[p] = t1;
+          } else if (t2 != t1) {
+            // TODO(vegorov) !!!
+            fail(arguments.positional[i], "Inferred T to be ${t1} and ${t2}.");
+          }
+        });
+      }
+    }
+
+    if (foundMapping.length != quantifiedVariables.length) {
+      fail(arguments,
+          "Failed to infer some type arguments: "
+          "${quantifiedVariables.where((p) => !foundMapping.containsKey(p))}");
+    }
+
+    arguments.types.length = typeParameters.length;
+    arguments.types.setRange(
+        0, arguments.types.length, typeParameters.map((p) => foundMapping[p]));
+  }
+
   DartType handleCall(Arguments arguments, FunctionNode function,
       {Substitution receiver: Substitution.empty,
       List<TypeParameter> typeParameters}) {
+    final parent = arguments.parent;
+    if (parent is StaticInvocation &&
+        parent.name.name == 'identical') {
+      if (arguments.named.length == 0 && arguments.positional.length == 2) {
+        var lhs = arguments.positional[0];
+        var rhs = arguments.positional[1];
+
+        if (checker.toTypeKind(lhs, visitExpression(lhs)) ==
+            checker.toTypeKind(rhs, visitExpression(rhs))) {
+          return environment.boolType;
+        }
+      }
+    }
+
     typeParameters ??= function.typeParameters;
     if (arguments.positional.length < function.requiredParameterCount) {
       fail(arguments, 'Too few positional arguments');
@@ -261,14 +797,30 @@
       return const BottomType();
     }
     if (arguments.types.length != typeParameters.length) {
-      fail(arguments, 'Wrong number of type arguments');
-      return const BottomType();
+      if (arguments.types.isEmpty && typeParameters.isNotEmpty) {
+        tryInferTypeArguments(function, receiver, arguments, typeParameters);
+      } else {
+        fail(arguments, '''
+Wrong number of type arguments:
+    expected ${function.functionType}
+    found    ${arguments}
+''');
+        return const BottomType();
+      }
+    } else if (arguments.types.isNotEmpty &&
+        arguments.types.every((t) => t == const DynamicType())) {
+      tryInferTypeArguments(function, receiver, arguments, typeParameters);
     }
+
     var instantiation = Substitution.fromPairs(typeParameters, arguments.types);
     var substitution = Substitution.combine(receiver, instantiation);
     for (int i = 0; i < typeParameters.length; ++i) {
       var argument = arguments.types[i];
-      var bound = substitution.substituteType(typeParameters[i].bound);
+      InterfaceType bound = substitution.substituteType(typeParameters[i].bound);
+      if (bound.classNode.supertype == null) {
+        // Ignore Object bound.
+        continue;
+      }
       checkAssignable(arguments, argument, bound);
     }
     for (int i = 0; i < arguments.positional.length; ++i) {
@@ -350,6 +902,10 @@
 
   @override
   DartType visitAsExpression(AsExpression node) {
+    if (node.type == const DynamicType()) {
+      fail(node, 'dynamic is not allowed in this context');
+    }
+    node.type = ensureNoDynamic(node.type);
     visitExpression(node.operand);
     return node.type;
   }
@@ -368,9 +924,15 @@
   DartType visitConditionalExpression(ConditionalExpression node) {
     node.condition =
         checkAndDowncastExpression(node.condition, environment.boolType);
-    node.then = checkAndDowncastExpression(node.then, node.staticType);
-    node.otherwise =
-        checkAndDowncastExpression(node.otherwise, node.staticType);
+
+    var thenType = visitExpression(node.then);
+    var otherwiseType = visitExpression(node.otherwise);
+
+    node.staticType = checker.leastUpperBound(node, thenType, otherwiseType);
+    node.then =
+        checkAndDowncastExpressionFrom(node.then, thenType, node.staticType);
+    node.otherwise = checkAndDowncastExpressionFrom(
+        node.otherwise, otherwiseType, node.staticType);
     return node.staticType;
   }
 
@@ -426,8 +988,25 @@
     return const BottomType();
   }
 
+  DartType ensureNoDynamic(DartType type) {
+    if (type == const DynamicType()) {
+      return environment.objectType;
+    } else if (type is InterfaceType && type.typeArguments.isNotEmpty) {
+      return new InterfaceType(type.classNode, type.typeArguments.map(ensureNoDynamic).toList());
+    } else if (type is FunctionType) {
+      return new FunctionType(type.positionalParameters.map(ensureNoDynamic).toList(), ensureNoDynamic(type.returnType),
+          namedParameters: type.namedParameters, typeParameters: type.typeParameters, requiredParameterCount: type.requiredParameterCount);
+    } else {
+      return type;
+    }
+  }
+
   @override
   DartType visitIsExpression(IsExpression node) {
+    if (node.type == const DynamicType()) {
+      fail(node, 'dynamic is not allowed in this context');
+    }
+    node.type = ensureNoDynamic(node.type);
     visitExpression(node.operand);
     return environment.boolType;
   }
@@ -443,25 +1022,86 @@
 
   @override
   DartType visitListLiteral(ListLiteral node) {
-    for (int i = 0; i < node.expressions.length; ++i) {
-      node.expressions[i] =
-          checkAndDowncastExpression(node.expressions[i], node.typeArgument);
+    if (node.typeArgument == const DynamicType()) {
+      if (node.expressions.isEmpty) {
+        fail(node,
+            'Empty array literals must have an explicitly specified type argument');
+      }
+
+      // We don't permit <dynamic>[...] lists.
+      DartType typeArg = null;
+      for (var expr in node.expressions) {
+        final DartType elemType = visitExpression(expr);
+        if (typeArg == null) {
+          typeArg = elemType;
+        } else if (typeArg != elemType) {
+          typeArg = checker.leastUpperBound(expr, typeArg, elemType);
+        }
+      }
+      node.typeArgument = typeArg;
+    } else {
+      for (int i = 0; i < node.expressions.length; ++i) {
+        node.expressions[i] =
+            checkAndDowncastExpression(node.expressions[i], node.typeArgument);
+      }
     }
+
     return environment.literalListType(node.typeArgument);
   }
 
   @override
   DartType visitLogicalExpression(LogicalExpression node) {
     node.left = checkAndDowncastExpression(node.left, environment.boolType);
+
+    final cond = node.left;
+    VariableDeclaration promoted;
+    DartType outerPromotion;
+
+    if (node.operator == '&&') {
+      if (cond is IsExpression) {
+        final val = cond.operand;
+        if (val is VariableGet &&
+            (val.variable.isFinal || !AssignmentFinder.hasAssignmentsTo(val.variable, node.right))) {
+          outerPromotion = promotions[val.variable];
+          promotions[val.variable] = cond.type;
+          promoted = val.variable;
+        }
+      }
+    }
     node.right = checkAndDowncastExpression(node.right, environment.boolType);
+    if (promoted != null) {
+      promotions[promoted] = outerPromotion;
+    }
     return environment.boolType;
   }
 
   @override
   DartType visitMapLiteral(MapLiteral node) {
+    final inferKey = node.keyType == const DynamicType();
+    final inferValue = node.valueType == const DynamicType();
+
     for (var entry in node.entries) {
-      entry.key = checkAndDowncastExpression(entry.key, node.keyType);
-      entry.value = checkAndDowncastExpression(entry.value, node.valueType);
+      if (inferKey) {
+        final type = visitExpression(entry.key);
+        if (node.keyType == const DynamicType()) {
+          node.keyType = type;
+        } else {
+          node.keyType = checker.leastUpperBound(entry, node.keyType, type);
+        }
+      } else {
+        entry.key = checkAndDowncastExpression(entry.key, node.keyType);
+      }
+
+      if (inferValue) {
+        final type = visitExpression(entry.value);
+        if (node.valueType == const DynamicType()) {
+          node.valueType = type;
+        } else {
+          node.valueType = checker.leastUpperBound(entry, node.valueType, type);
+        }
+      } else {
+        entry.value = checkAndDowncastExpression(entry.value, node.valueType);
+      }
     }
     return environment.literalMapType(node.keyType, node.valueType);
   }
@@ -483,7 +1123,7 @@
       return const BottomType();
     }
     if (function.typeParameters.length != arguments.types.length) {
-      fail(access, 'Wrong number of type arguments');
+      fail(access, 'Wrong number of type arguments: expected ${function}, found ${arguments}');
       return const BottomType();
     }
     var instantiation =
@@ -517,54 +1157,213 @@
     return instantiation.substituteType(function.returnType);
   }
 
+  final LookupCache lookupCache = new LookupCache();
+
+  static bool isBinaryArithmeticOperator(String name) {
+    return name == '+' ||
+        name == '-' ||
+        name == '*' ||
+        name == 'remainder' ||
+        name == '%' ||
+        name == '/' ||
+        name == '~/';
+  }
+
+  static bool isBinaryComparisonOperator(String name) {
+    return name == '==' ||
+        name == '!=' ||
+        name == '<' ||
+        name == '>' ||
+        name == '<=' ||
+        name == '>=';
+  }
+
+  void checkArguments(Arguments args, int expected) {
+    if (args.types.isNotEmpty) {
+      fail(args.parent, "Expected no type arguments");
+    }
+
+    if (args.named.isNotEmpty) {
+      fail(args.parent, "Expected no named arguments");
+    }
+
+    if (args.positional.length != expected) {
+      fail(args.parent,
+          "Expected ${expected} arguments, got ${args.positional.length}");
+    }
+  }
+
+  Member resolveInvocation(DartType receiver, MethodInvocation node) {
+    if (receiver is InterfaceType) {
+      return lookupCache.lookupInterfaceSelector(
+          receiver.classNode, new Selector(SelectorKind.Method, node.name));
+    } else if (receiver is FunctionType) {
+      if (node.name.name == 'call') {
+        return environment.invokeClosure;
+      } else if (node.name.name == '==') {
+        return coreTypes.getMember('dart:core', 'Object', '==');
+      }
+    } else if (receiver is TypeParameterType) {
+      return resolveInvocation(receiver.parameter.bound, node);
+    }
+
+    return null;
+  }
+
   @override
   DartType visitMethodInvocation(MethodInvocation node) {
+    if (isUntypedLambda(node.receiver) && node.name.name == 'call') {
+      assert(node.arguments.named.isEmpty);
+      handleUntypedLambda(
+          node.receiver,
+          new FunctionType(
+              node.arguments.positional.map(visitExpression).toList(),
+              const DynamicType()),
+          new Set<TypeParameter>());
+    }
+
+    final receiver = visitExpression(node.receiver);
+
     var target = node.interfaceTarget;
     if (target == null) {
-      var receiver = visitExpression(node.receiver);
-      if (node.name.name == '==') {
-        visitExpression(node.arguments.positional.single);
-        return environment.boolType;
+      target = resolveInvocation(receiver, node);
+      if (target == null) {
+        fail(node, "Failed to resolve ${node.name} for ${receiver}");
       }
-      if (node.name.name == 'call' && receiver is FunctionType) {
-        return handleFunctionCall(node, receiver, node.arguments);
+      node.interfaceTarget = target;
+    }
+
+    if (target == environment.invokeClosure) {
+      return handleFunctionCall(node, receiver, node.arguments);
+    }
+
+    final receiverKind = checker.toTypeKind(node.receiver, receiver);
+
+    if (receiverKind != TypeKind.Reference &&
+        target.enclosingClass == coreTypes.numClass) {
+      final isArithmetic = isBinaryArithmeticOperator(node.name.name);
+      final isComparison = isBinaryComparisonOperator(node.name.name);
+      if (isArithmetic || isComparison) {
+        checkArguments(node.arguments, 1);
+        final rhs = node.arguments.positional[0];
+        final argument = visitExpression(rhs);
+        final argumentKind = checker.toTypeKind(rhs, argument);
+
+        if (argumentKind == TypeKind.Reference) {
+          fail(node,
+              "Second argument must be numeric: ${receiver} ${node.name.name} ${argument}");
+        }
+
+        var resultKind = receiverKind;
+        if (receiverKind != argumentKind) {
+          // Argument conversion is necessary.
+          final toDouble = coreTypes.getMember('dart:core', 'num', 'toDouble');
+          if (receiverKind == TypeKind.Double) {
+            node.arguments.positional[0] =
+                new DirectMethodInvocation(rhs, toDouble, new Arguments.empty())
+                  ..parent = node.arguments;
+          } else {
+            node.receiver = new DirectMethodInvocation(
+                node.receiver, toDouble, new Arguments.empty())
+              ..parent = node;
+          }
+          resultKind = TypeKind.Double;
+        }
+
+        if (node.name.name == '/') {
+          resultKind = TypeKind.Double;
+        }
+
+        return isComparison
+            ? environment.boolType
+            : (resultKind == TypeKind.Integer
+                ? environment.intType
+                : environment.doubleType);
       }
-      return handleDynamicCall(receiver, node.arguments);
-    } else if (environment.isOverloadedArithmeticOperator(target)) {
-      assert(node.arguments.positional.length == 1);
-      var receiver = visitExpression(node.receiver);
-      var argument = visitExpression(node.arguments.positional[0]);
-      return environment.getTypeOfOverloadedArithmetic(receiver, argument);
+
+      // fail(node, 'Numeric expression requires special rules. ${target}');
+    }
+
+    if (target is Procedure) {
+      if (environment.isOverloadedArithmeticOperator(target)) {
+        assert(node.arguments.positional.length == 1);
+        var argument = visitExpression(node.arguments.positional[0]);
+        return environment.getTypeOfOverloadedArithmetic(receiver, argument);
+      } else {
+        return handleCall(node.arguments, target.function,
+            receiver: getReceiverTypeImpl(
+              receiver, node, node.receiver, node.interfaceTarget));
+      }
+    } else if (target is Field) {
+      if (target.type is! FunctionType) {
+        fail(node, 'Expression does not evaluate to function');
+      }
+
+      return handleFunctionCall(node, target.type, node.arguments);
     } else {
-      return handleCall(node.arguments, target.function,
-          receiver: getReceiverType(node, node.receiver, node.interfaceTarget));
+      fail(node, 'Unexpected target: ${target}');
     }
   }
 
   @override
   DartType visitPropertyGet(PropertyGet node) {
-    if (node.interfaceTarget == null) {
-      visitExpression(node.receiver);
-      return const DynamicType();
-    } else {
-      var receiver = getReceiverType(node, node.receiver, node.interfaceTarget);
-      return receiver.substituteType(node.interfaceTarget.getterType);
+    var target = node.interfaceTarget;
+    if (target == null) {
+      final receiver = visitExpression(node.receiver);
+
+      if (receiver is InterfaceType) {
+        target = lookupCache.lookupInterfaceSelector(
+            receiver.classNode, new Selector(SelectorKind.Getter, node.name));
+        if (target == null) {
+          fail(node, 'Failed to lookup ${node.name} on ${receiver}');
+          return const BottomType();
+        }
+        node.interfaceTarget = target;
+      } else if (receiver is FunctionType) {
+        fail(node, "Can't dispatch on FunctionType");
+        return const BottomType();
+      } else {
+        fail(node, "Can't dispatch on ${receiver}.");
+        return const BottomType();
+      }
     }
+
+    var receiver = getReceiverType(node, node.receiver, node.interfaceTarget);
+    return receiver.substituteType(node.interfaceTarget.getterType);
   }
 
   @override
   DartType visitPropertySet(PropertySet node) {
-    var value = visitExpression(node.value);
-    if (node.interfaceTarget != null) {
-      var receiver = getReceiverType(node, node.receiver, node.interfaceTarget);
-      checkAssignable(
-          node.value,
-          value,
-          receiver.substituteType(node.interfaceTarget.setterType,
-              contravariant: true));
-    } else {
-      visitExpression(node.receiver);
+    var target = node.interfaceTarget;
+    if (target == null) {
+      final receiver = visitExpression(node.receiver);
+
+      if (receiver is InterfaceType) {
+        target = lookupCache.lookupInterfaceSelector(
+            receiver.classNode, new Selector(SelectorKind.Setter, node.name));
+        if (target == null) {
+          fail(node, 'Failed to lookup ${node.name} on ${receiver}');
+          return const BottomType();
+        }
+        node.interfaceTarget = target;
+      } else if (receiver is FunctionType) {
+        fail(node, "Can't dispatch on FunctionType");
+        return const BottomType();
+      } else {
+        fail(node, "Can't dispatch on ${receiver}.");
+        return const BottomType();
+      }
     }
+
+    var value = visitExpression(node.value);
+    var receiver = getReceiverType(node, node.receiver, node.interfaceTarget);
+
+    node.value = checkAndDowncastExpressionFrom(
+        node.value,
+        value,
+        receiver.substituteType(node.interfaceTarget.setterType,
+            contravariant: true));
+
     return value;
   }
 
@@ -669,6 +1468,7 @@
 
   @override
   DartType visitVariableGet(VariableGet node) {
+    node.promotedType ??= promotions[node.variable];
     return node.promotedType ?? node.variable.type;
   }
 
@@ -742,9 +1542,32 @@
     return node.functionType;
   }
 
+  final List<Object> rollback = [];
+
   @override
   visitAssertStatement(AssertStatement node) {
     visitExpression(node.condition);
+
+    if (node.parent is Block) {
+      final cond = node.condition;
+      if (cond is IsExpression) {
+        final val = cond.operand;
+        if (val is VariableGet &&
+            (val.variable.isFinal || !AssignmentFinder.hasAssignmentsTo(val.variable, node.parent))) {
+          final outerPromotion = promotions[val.variable];
+          promotions[val.variable] = cond.type;
+          if (rollback.isEmpty ||
+              rollback[rollback.length - 1] != node.parent) {
+            rollback.add(new Map<VariableDeclaration, DartType>());
+            rollback.add(node.parent);
+          }
+
+          Map<VariableDeclaration, DartType> m = rollback[rollback.length - 2];
+          m[val.variable] = outerPromotion;
+        }
+      }
+    }
+
     if (node.message != null) {
       visitExpression(node.message);
     }
@@ -753,6 +1576,11 @@
   @override
   visitBlock(Block node) {
     node.statements.forEach(visitStatement);
+    if (rollback.isNotEmpty && rollback.last == node) {
+      Map<VariableDeclaration, DartType> m = rollback[rollback.length - 2];
+      m.forEach((v, t) => promotions[v] = t);
+      rollback.length -= 2;
+    }
   }
 
   @override
@@ -841,13 +1669,32 @@
   @override
   visitFunctionDeclaration(FunctionDeclaration node) {
     handleNestedFunctionNode(node.function);
+    node.variable.type = node.function.functionType;
   }
 
+  final Map<VariableDeclaration, DartType> promotions =
+      <VariableDeclaration, DartType>{};
+
   @override
   visitIfStatement(IfStatement node) {
     node.condition =
         checkAndDowncastExpression(node.condition, environment.boolType);
+    final cond = node.condition;
+    VariableDeclaration promoted;
+    DartType outerPromotion;
+    if (cond is IsExpression) {
+      final val = cond.operand;
+      if (val is VariableGet &&
+          (val.variable.isFinal || !AssignmentFinder.hasAssignmentsTo(val.variable, node.then))) {
+        outerPromotion = promotions[val.variable];
+        promotions[val.variable] = cond.type;
+        promoted = val.variable;
+      }
+    }
     visitStatement(node.then);
+    if (promoted != null) {
+      promotions[promoted] = outerPromotion;
+    }
     if (node.otherwise != null) {
       visitStatement(node.otherwise);
     }
@@ -867,10 +1714,25 @@
       if (environment.returnType == null) {
         fail(node, 'Return of a value from void method');
       } else {
+        if (environment.returnType != const DynamicType()) {
+          if (isUntypedLambda(node.expression)) {
+            handleUntypedLambda(node.expression, environment.returnType,
+                new Set<TypeParameter>());
+          }
+        }
+
         var type = visitExpression(node.expression);
         if (environment.currentAsyncMarker == AsyncMarker.Async) {
           type = environment.unfutureType(type);
         }
+        if (environment.returnType == const DynamicType()) {
+          if (!environment.canInferReturnType) {
+            fail(node, 'Functions can not have dynamic return type');
+          }
+
+          environment.returnType = type;
+        }
+
         checkAssignable(node.expression, type, environment.returnType);
       }
     }
@@ -889,6 +1751,12 @@
   visitTryCatch(TryCatch node) {
     visitStatement(node.body);
     for (var catchClause in node.catches) {
+      if (catchClause.exception?.type == const DynamicType()) {
+        catchClause.exception.type = environment.objectType;
+      }
+      if (catchClause.stackTrace?.type == const DynamicType()) {
+        catchClause.stackTrace.type = environment.objectType;
+      }
       visitStatement(catchClause.body);
     }
   }
@@ -901,7 +1769,15 @@
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
-    if (node.initializer != null) {
+    if (node.type == const DynamicType()) {
+      if (node.initializer == null) {
+        fail(
+            node, 'Local variables declarated with var must have initializers');
+      }
+      node.type = visitExpression(node.initializer);
+    } else if (node.initializer != null) {
+      node.type = ensureNoDynamic(node.type);
+      fixupInitializer(node);
       node.initializer =
           checkAndDowncastExpression(node.initializer, node.type);
     }
diff --git a/pkg/kernel/lib/type_environment.dart b/pkg/kernel/lib/type_environment.dart
index 0b90cb4..1bf8409 100644
--- a/pkg/kernel/lib/type_environment.dart
+++ b/pkg/kernel/lib/type_environment.dart
@@ -15,15 +15,19 @@
   final ClassHierarchy hierarchy;
   InterfaceType thisType;
 
+  bool canInferReturnType = false;
+
   DartType returnType;
   DartType yieldType;
   AsyncMarker currentAsyncMarker = AsyncMarker.Sync;
 
+  Procedure invokeClosure;
+
   /// An error handler for use in debugging, or `null` if type errors should not
   /// be tolerated.  See [typeError].
   ErrorHandler errorHandler;
 
-  TypeEnvironment(this.coreTypes, this.hierarchy);
+  TypeEnvironment(this.coreTypes, this.hierarchy) : invokeClosure = coreTypes.getMember('dart:core', '_Closure', '_invoke') as Procedure;
 
   InterfaceType get objectType => coreTypes.objectClass.rawType;
   InterfaceType get nullType => coreTypes.nullClass.rawType;
@@ -38,6 +42,7 @@
 
   Class get intClass => coreTypes.intClass;
   Class get numClass => coreTypes.numClass;
+  Class get futureOrClass => coreTypes.futureOrClass;
 
   InterfaceType literalListType(DartType elementType) {
     return new InterfaceType(coreTypes.listClass, <DartType>[elementType]);
@@ -139,6 +144,7 @@
 ///
 /// This lives in a separate class so it can be tested independently of the SDK.
 abstract class SubtypeTester {
+  Class get futureOrClass;
   InterfaceType get objectType;
   InterfaceType get rawFunctionType;
   ClassHierarchy get hierarchy;
@@ -153,6 +159,13 @@
       return true;
     }
     if (subtype is InterfaceType && supertype is InterfaceType) {
+      if (supertype.classNode == futureOrClass &&
+          supertype.typeArguments.length == 1) {
+        if (isSubtypeOf(subtype, supertype.typeArguments[0])) {
+          return true;
+        }
+      }
+
       var upcastType =
           hierarchy.getTypeAsInstanceOf(subtype, supertype.classNode);
       if (upcastType == null) return false;
diff --git a/pkg/kernel/lib/vm/native_effects.dart b/pkg/kernel/lib/vm/native_effects.dart
index af15fed..33e5808 100644
--- a/pkg/kernel/lib/vm/native_effects.dart
+++ b/pkg/kernel/lib/vm/native_effects.dart
@@ -114,6 +114,7 @@
     'Async_rethrow': NoEffect,
     'Bigint_allocate': AllocatesClassEffect('dart:core', '_Bigint'),
     'Bool_fromEnvironment': NoEffect,
+    'Closure_invoke': NoEffect,
     'DateTime_timeZoneOffsetInSeconds': NoEffect,
     'Developer_lookupExtension': NoEffect,
     'Developer_registerExtension': NoEffect,
@@ -159,7 +160,10 @@
     'Object_simpleInstanceOf': NoEffect,
     'OneByteString_splitWithCharCode': StringAllocationEffect,
     'OneByteString_substringUnchecked': StringAllocationEffect,
-    'RawReceivePortImpl_factory': NoEffect,
+    'RawReceivePortImpl_factory': AllocatesClassEffect('dart:isolate', '_RawReceivePortImpl'),
+    'RawReceivePortImpl_get_id': NoEffect,
+    'RawReceivePortImpl_get_sendport': NoEffect,
+    'RawReceivePortImpl_closeInternal': NoEffect,
     'RegExp_factory': AllocatesClassEffect('dart:core', '_RegExp'),
     'Smi_bitAndFromSmi': NoEffect,
     'Smi_bitNegate': NoEffect,
diff --git a/pkg/kernel/lib/vm/roots.dart b/pkg/kernel/lib/vm/roots.dart
index 0987d49..ce6f402 100644
--- a/pkg/kernel/lib/vm/roots.dart
+++ b/pkg/kernel/lib/vm/roots.dart
@@ -34,13 +34,14 @@
     keepClass('Stream', library: 'dart:async'),
     keepClass('Symbol', library: 'dart:_internal'),
 
-    keepClass('_Smi'), // Implies int, num
+    keepClass('_Integer'), // Implies int, num
     keepClass('_Double'), // Implies double, num
     keepClass('_OneByteString'), // Implies String
     keepClass('_TwoByteString'), // Implies String
     keepClass('_List'), // Implies List
 
     keepClass('_Closure'),
+    keepProcedure('_Closure', '_invoke', library: 'dart:core'),
     keepProcedure('_StringBase', '_interpolate'),
     keepProcedure('List', '_fromLiteral'),
 
diff --git a/runtime/lib/compact_hash.dart b/runtime/lib/compact_hash.dart
index 923c08f..659df35 100644
--- a/runtime/lib/compact_hash.dart
+++ b/runtime/lib/compact_hash.dart
@@ -33,7 +33,7 @@
   // Note: All fields are initialized in a single constructor so that the VM
   // recognizes they cannot hold null values. This makes a big (20%) performance
   // difference on some operations.
-  _HashFieldBase(int dataSize) : this._data = new List(dataSize);
+  _HashFieldBase(int dataSize) : this._data = new List<Object>(dataSize);
 }
 
 // Base class for VM-internal classes; keep in sync with _HashFieldBase.
@@ -99,7 +99,7 @@
   // A self-loop is used to mark a deleted key or value.
   static bool _isDeleted(List data, Object keyOrValue) =>
       identical(keyOrValue, data);
-  static void _setDeletedAt(List data, int d) {
+  static void _setDeletedAt(List<Object> data, int d) {
     data[d] = data;
   }
 
diff --git a/runtime/lib/internal_patch.dart b/runtime/lib/internal_patch.dart
index cddf30a..c422937 100644
--- a/runtime/lib/internal_patch.dart
+++ b/runtime/lib/internal_patch.dart
@@ -27,11 +27,11 @@
   static var resourceReadAsBytes;
 
   // Implementation of package root/map provision.
-  static var packageRootString;
-  static var packageConfigString;
-  static var packageRootUriFuture;
-  static var packageConfigUriFuture;
-  static var resolvePackageUriFuture;
+  static String packageRootString;
+  static String packageConfigString;
+  static Object /* Future<Uri> */ packageRootUriFuture;
+  static Object /* Future<Uri> */ packageConfigUriFuture;
+  static Object /* Future<Uri> */ resolvePackageUriFuture;
 
   static var platformScript;
 }
@@ -50,7 +50,7 @@
 
 // Utility class now only used by the VM.
 class Lists {
-  static void copy(List src, int srcStart, List dst, int dstStart, int count) {
+  static void copy<E>(List<E> src, int srcStart, List<E> dst, int dstStart, int count) {
     if (srcStart < dstStart) {
       for (int i = srcStart + count - 1, j = dstStart + count - 1;
           i >= srcStart;
diff --git a/runtime/lib/isolate_patch.dart b/runtime/lib/isolate_patch.dart
index 96144fd..26039d2 100644
--- a/runtime/lib/isolate_patch.dart
+++ b/runtime/lib/isolate_patch.dart
@@ -134,8 +134,8 @@
   }
 
   /**** Internal implementation details ****/
-  _get_id() native "RawReceivePortImpl_get_id";
-  _get_sendport() native "RawReceivePortImpl_get_sendport";
+  int _get_id() native "RawReceivePortImpl_get_id";
+  SendPort _get_sendport() native "RawReceivePortImpl_get_sendport";
 
   // Called from the VM to retrieve the handler for a message.
   static _lookupHandler(int id) {
@@ -161,17 +161,12 @@
 
   // TODO(iposva): Ideally keep this map in the VM.
   // id to handler mapping.
-  static _initHandlerMap() {
+  static Map<int, Function> _initHandlerMap() {
     // TODO(18511): Workaround bad CheckSmi hoisting.
-    var tempMap = new HashMap();
-    // Collect feedback that not all keys are Smis.
-    tempMap["."] = 1;
-    tempMap["."] = 2;
-
-    return new HashMap();
+    return new HashMap<int, Function>();
   }
 
-  static final Map _handlerMap = _initHandlerMap();
+  static final Map<int, Function> _handlerMap = _initHandlerMap();
 }
 
 class _SendPortImpl implements SendPort {
diff --git a/runtime/lib/math_patch.dart b/runtime/lib/math_patch.dart
index a09ad93..32dee8b 100644
--- a/runtime/lib/math_patch.dart
+++ b/runtime/lib/math_patch.dart
@@ -93,8 +93,8 @@
 @patch
 class Random {
   @patch
-  factory Random([int seed]) {
-    var state = _Random._setupSeed((seed == null) ? _Random._nextSeed() : seed);
+  factory Random([int seed = -1]) {
+    var state = _Random._setupSeed((seed == -1) ? _Random._nextSeed() : seed);
     // Crank a couple of times to distribute the seed bits a bit further.
     return new _Random._withState(state)
       .._nextState()
@@ -143,8 +143,8 @@
       return _state[_kSTATE_LO] & (max - 1);
     }
 
-    var rnd32;
-    var result;
+    int rnd32;
+    int result;
     do {
       _nextState();
       rnd32 = _state[_kSTATE_LO];
diff --git a/runtime/lib/object_patch.dart b/runtime/lib/object_patch.dart
index 87b1097..59bcc04 100644
--- a/runtime/lib/object_patch.dart
+++ b/runtime/lib/object_patch.dart
@@ -6,7 +6,7 @@
 class Object {
   // The VM has its own implementation of equals.
   @patch
-  bool operator ==(other) native "Object_equals";
+  bool operator ==(Object other) native "Object_equals";
 
   // Helpers used to implement hashCode. If a hashCode is used, we remember it
   // in a weak table in the VM. A new hashCode value is calculated using a
diff --git a/runtime/lib/timer_patch.dart b/runtime/lib/timer_patch.dart
index e5f7b06..5c19d8b 100644
--- a/runtime/lib/timer_patch.dart
+++ b/runtime/lib/timer_patch.dart
@@ -10,7 +10,7 @@
   static Timer _createTimer(Duration duration, void callback()) {
     // TODO(iposva): Remove _TimerFactory and use VMLibraryHooks exclusively.
     if (_TimerFactory._factory == null) {
-      _TimerFactory._factory = VMLibraryHooks.timerFactory;
+      _TimerFactory._factory = VMLibraryHooks.timerFactory as _TimerFactoryClosure;
     }
     if (_TimerFactory._factory == null) {
       throw new UnsupportedError("Timer interface not supported.");
@@ -27,7 +27,7 @@
       Duration duration, void callback(Timer timer)) {
     // TODO(iposva): Remove _TimerFactory and use VMLibraryHooks exclusively.
     if (_TimerFactory._factory == null) {
-      _TimerFactory._factory = VMLibraryHooks.timerFactory;
+      _TimerFactory._factory = VMLibraryHooks.timerFactory as _TimerFactoryClosure;
     }
     if (_TimerFactory._factory == null) {
       throw new UnsupportedError("Timer interface not supported.");
diff --git a/runtime/vm/BUILD.gn b/runtime/vm/BUILD.gn
index 485a928..34690bf 100644
--- a/runtime/vm/BUILD.gn
+++ b/runtime/vm/BUILD.gn
@@ -453,6 +453,43 @@
   }
 }
 
+action("compile_vipunen_platform") {
+  if (!prebuilt_dart_exe_works) {
+    deps += [ "../bin:dart_bootstrap($host_toolchain)" ]
+  }
+
+  script = "../../tools/compile_platform.py"
+
+  # We list the `patch_sdk.dart` tool here because the [script] (which is
+  # implicitly an input) will call it.
+  inputs = [
+    "../../tools/compile_platform.dart",
+  ]
+  depfile = "${root_out_dir}/vipunen_platform.dill.d"
+
+  outputs = [
+    # Instead of listing all outputs we list a single well-known one.
+    "${root_out_dir}/vipunen_platform.dill",
+  ]
+
+  args = [ "--quiet" ]
+  if (!prebuilt_dart_exe_works) {
+    dart_out_dir = get_label_info("../bin:dart_bootstrap($host_toolchain)",
+                                  "root_out_dir")
+    dart_bootstrap =
+        rebase_path("$dart_out_dir/dart_bootstrap$executable_suffix")
+    args += [
+      "--dart-executable",
+      dart_bootstrap,
+    ]
+  }
+  args += [
+    rebase_path("../../vipunen/patched_sdk"),
+    rebase_path("../../.packages"),
+    "./vipunen_platform.dill",
+  ]
+}
+
 generate_patched_sdk("patched_sdk") {
   libraries = [
     [
diff --git a/sdk/lib/async/async_error.dart b/sdk/lib/async/async_error.dart
index e575b41..ac95f2a 100644
--- a/sdk/lib/async/async_error.dart
+++ b/sdk/lib/async/async_error.dart
@@ -15,11 +15,11 @@
 }
 
 Function _registerErrorHandler<R>(Function errorHandler, Zone zone) {
-  if (errorHandler is ZoneBinaryCallback) {
+  if (errorHandler is ZoneBinaryCallback<R, Object, StackTrace>) {
     return zone.registerBinaryCallback<R, Object, StackTrace>(
-        errorHandler as dynamic/*=ZoneBinaryCallback<R, Object, StackTrace>*/);
+        errorHandler);
   } else {
     return zone.registerUnaryCallback<R, Object>(
-        errorHandler as dynamic/*=ZoneUnaryCallback<R, Object>*/);
+        errorHandler as ZoneUnaryCallback<R, Object>);
   }
 }
diff --git a/sdk/lib/async/future_impl.dart b/sdk/lib/async/future_impl.dart
index 14bac61..774f760 100644
--- a/sdk/lib/async/future_impl.dart
+++ b/sdk/lib/async/future_impl.dart
@@ -211,7 +211,7 @@
     _asyncComplete(result);
   }
 
-  _Future.immediateError(var error, [StackTrace stackTrace]) {
+  _Future.immediateError(Object error, [StackTrace stackTrace]) {
     _asyncCompleteError(error, stackTrace);
   }
 
diff --git a/sdk/lib/async/stream_controller.dart b/sdk/lib/async/stream_controller.dart
index 1f15703..0a599fc 100644
--- a/sdk/lib/async/stream_controller.dart
+++ b/sdk/lib/async/stream_controller.dart
@@ -797,7 +797,7 @@
   try {
     notificationHandler();
   } catch (e, s) {
-    Zone.current.handleUncaughtError(e, s);
+    Zone.current.handleUncaughtError<Object>(e, s);
   }
 }
 
diff --git a/sdk/lib/async/stream_impl.dart b/sdk/lib/async/stream_impl.dart
index 9ae7342..096ccd5 100644
--- a/sdk/lib/async/stream_impl.dart
+++ b/sdk/lib/async/stream_impl.dart
@@ -556,7 +556,7 @@
 
 /** Default error handler, reports the error to the current zone's handler. */
 void _nullErrorHandler(Object error, [StackTrace stackTrace]) {
-  Zone.current.handleUncaughtError(error, stackTrace);
+  Zone.current.handleUncaughtError<Object>(error, stackTrace);
 }
 
 /** Default done handler, does nothing. */
diff --git a/sdk/lib/async/stream_pipe.dart b/sdk/lib/async/stream_pipe.dart
index 73ed6b1..a4b84d4 100644
--- a/sdk/lib/async/stream_pipe.dart
+++ b/sdk/lib/async/stream_pipe.dart
@@ -6,7 +6,7 @@
 
 /** Runs user code and takes actions depending on success or failure. */
 _runUserCode<T>(
-    T userCode(), onSuccess(T value), onError(error, StackTrace stackTrace)) {
+    T userCode(), onSuccess(T value), onError(Object error, StackTrace stackTrace)) {
   try {
     onSuccess(userCode());
   } catch (e, s) {
@@ -43,7 +43,7 @@
   _cancelAndError(subscription, future, error, stackTrace);
 }
 
-typedef void _ErrorCallback(error, StackTrace stackTrace);
+typedef void _ErrorCallback(Object error, StackTrace stackTrace);
 
 /** Helper function to make an onError argument to [_runUserCode]. */
 _ErrorCallback _cancelAndErrorClosure(
diff --git a/sdk/lib/async/zone.dart b/sdk/lib/async/zone.dart
index 7720be9..f681eff 100644
--- a/sdk/lib/async/zone.dart
+++ b/sdk/lib/async/zone.dart
@@ -1355,7 +1355,7 @@
   // Methods that can be customized by the zone specification.
 
   R handleUncaughtError<R>(error, StackTrace stackTrace) {
-    return _rootHandleUncaughtError(null, null, this, error, stackTrace);
+    return _rootHandleUncaughtError<R>(null, null, this, error, stackTrace);
   }
 
   Zone fork({ZoneSpecification specification, Map zoneValues}) {
diff --git a/sdk/lib/collection/iterable.dart b/sdk/lib/collection/iterable.dart
index 6fc4128..1d553dc 100644
--- a/sdk/lib/collection/iterable.dart
+++ b/sdk/lib/collection/iterable.dart
@@ -22,7 +22,7 @@
   Iterable<T>
       expand<T>(Iterable<T> f(E element)) => new ExpandIterable<E, T>(this, f);
 
-  bool contains(Object element) {
+  bool contains(E element) {
     for (E e in this) {
       if (e == element) return true;
     }
@@ -215,7 +215,7 @@
    * Handles circular references where converting one of the elements
    * to a string ends up converting [iterable] to a string again.
    */
-  static String iterableToShortString(Iterable iterable,
+  static String iterableToShortString<E>(Iterable<E> iterable,
       [String leftDelimiter = '(', String rightDelimiter = ')']) {
     if (_isToStringVisiting(iterable)) {
       if (leftDelimiter == "(" && rightDelimiter == ")") {
@@ -224,7 +224,7 @@
       }
       return "$leftDelimiter...$rightDelimiter";
     }
-    List parts = [];
+    List<String> parts = <String>[];
     _toStringVisiting.add(iterable);
     try {
       _iterablePartsToStrings(iterable, parts);
@@ -257,7 +257,7 @@
 }
 
 /** A set used to identify cyclic lists during toString() calls. */
-final List _toStringVisiting = [];
+final List<Object> _toStringVisiting = <Object>[];
 
 /** Check if we are currently visiting `o` in a toString call. */
 bool _isToStringVisiting(Object o) {
@@ -270,7 +270,7 @@
 /**
  * Convert elments of [iterable] to strings and store them in [parts].
  */
-void _iterablePartsToStrings(Iterable iterable, List parts) {
+void _iterablePartsToStrings<E>(Iterable<E> iterable, List<String> parts) {
   /*
    * This is the complicated part of [iterableToShortString].
    * It is extracted as a separate function to avoid having too much code
@@ -311,8 +311,8 @@
 
   // Find last two elements. One or more of them may already be in the
   // parts array. Include their length in `length`.
-  var penultimate = null;
-  var ultimate = null;
+  E penultimate = null;
+  E ultimate = null;
   if (!it.moveNext()) {
     if (count <= HEAD_COUNT + TAIL_COUNT) return;
     ultimateString = parts.removeLast();
diff --git a/sdk/lib/collection/list.dart b/sdk/lib/collection/list.dart
index 9f6858e..14bf4e8 100644
--- a/sdk/lib/collection/list.dart
+++ b/sdk/lib/collection/list.dart
@@ -90,7 +90,7 @@
     return this[0];
   }
 
-  bool contains(Object element) {
+  bool contains(E element) {
     int length = this.length;
     for (int i = 0; i < this.length; i++) {
       if (this[i] == element) return true;
@@ -208,7 +208,7 @@
     return value;
   }
 
-  Iterable<E> skip(int count) => new SubListIterable<E>(this, count, null);
+  Iterable<E> skip(int count) => new SubListIterable<E>(this, count, SubListIterable.UpToLength);
 
   Iterable<E> skipWhile(bool test(E element)) {
     return new SkipWhileIterable<E>(this, test);
@@ -256,7 +256,7 @@
     }
   }
 
-  bool remove(Object element) {
+  bool remove(E element) {
     for (int i = 0; i < this.length; i++) {
       if (this[i] == element) {
         this.setRange(i, this.length - 1, this, i + 1);
@@ -275,7 +275,7 @@
     _filter(test, true);
   }
 
-  void _filter(bool test(var element), bool retainMatching) {
+  void _filter(bool test(E element), bool retainMatching) {
     List<E> retained = <E>[];
     int length = this.length;
     for (int i = 0; i < length; i++) {
@@ -334,9 +334,9 @@
     return new ListMapView<E>(this);
   }
 
-  List<E> sublist(int start, [int end]) {
+  List<E> sublist(int start, [int end = -1]) {
     int listLength = this.length;
-    if (end == null) end = listLength;
+    if (end == -1) end = listLength;
     RangeError.checkValidRange(start, end, listLength);
     int length = end - start;
     List<E> result = new List<E>()..length = length;
@@ -374,8 +374,9 @@
     List<E> otherList;
     int otherStart;
     // TODO(floitsch): Make this accept more.
-    if (iterable is List<E>) {
-      otherList = iterable;
+    final it = iterable;
+    if (it is List<E>) {
+      otherList = it;
       otherStart = skipCount;
     } else {
       otherList = iterable.skip(skipCount).toList(growable: false);
@@ -422,7 +423,7 @@
     }
   }
 
-  int indexOf(Object element, [int startIndex = 0]) {
+  int indexOf(E element, [int startIndex = 0]) {
     if (startIndex >= this.length) {
       return -1;
     }
@@ -442,8 +443,8 @@
    * the search at index [startIndex] to 0.
    * Returns -1 if [element] is not found.
    */
-  int lastIndexOf(Object element, [int startIndex]) {
-    if (startIndex == null) {
+  int lastIndexOf(E element, [int startIndex = -1]) {
+    if (startIndex == -1) {
       startIndex = this.length - 1;
     } else {
       if (startIndex < 0) {
@@ -470,7 +471,7 @@
     // We are modifying the length just below the is-check. Without the check
     // Array.copy could throw an exception, leaving the list in a bad state
     // (with a length that has been increased, but without a new element).
-    if (index is! int) throw new ArgumentError(index);
+    // if (index is! int) throw new ArgumentError(index);
     this.length++;
     setRange(index + 1, this.length, this, index);
     this[index] = element;
@@ -504,7 +505,7 @@
   }
 
   void setAll(int index, Iterable<E> iterable) {
-    if (iterable is List) {
+    if (iterable is List<E>) {
       setRange(index, index + iterable.length, iterable);
     } else {
       for (E element in iterable) {
diff --git a/sdk/lib/collection/maps.dart b/sdk/lib/collection/maps.dart
index 680d440..5821065 100644
--- a/sdk/lib/collection/maps.dart
+++ b/sdk/lib/collection/maps.dart
@@ -304,7 +304,7 @@
    * A typical implementation of a map's [toString] method will
    * simply return the results of this method applied to the collection.
    */
-  static String mapToString(Map m) {
+  static String mapToString<K, V>(Map<K, V> m) {
     // Reuse the list in IterableBase for detecting toString cycles.
     if (_isToStringVisiting(m)) {
       return '{...}';
@@ -340,8 +340,8 @@
    *
    * This method is used by Map classes in the named constructor fromIterable.
    */
-  static void _fillMapWithMappedIterable(
-      Map map, Iterable iterable, key(element), value(element)) {
+  static void _fillMapWithMappedIterable<K, V, E>(
+      Map<K, V> map, Iterable<E> iterable, K key(E element), V value(E element)) {
     if (key == null) key = _id;
     if (value == null) value = _id;
 
@@ -355,7 +355,7 @@
    *
    * This method is used by Map classes in the named constructor fromIterables.
    */
-  static void _fillMapWithIterables(Map map, Iterable keys, Iterable values) {
+  static void _fillMapWithIterables<K, V> (Map<K, V> map, Iterable<K> keys, Iterable<V> values) {
     Iterator keyIterator = keys.iterator;
     Iterator valueIterator = values.iterator;
 
diff --git a/sdk/lib/convert/json.dart b/sdk/lib/convert/json.dart
index cf4a677..7f144d9 100644
--- a/sdk/lib/convert/json.dart
+++ b/sdk/lib/convert/json.dart
@@ -56,8 +56,8 @@
  */
 const JsonCodec JSON = const JsonCodec();
 
-typedef _Reviver(var key, var value);
-typedef _ToEncodable(var o);
+typedef Object _Reviver(String key, Object value);
+typedef Object _ToEncodable(Object o);
 
 /**
  * A [JsonCodec] encodes JSON objects to strings and decodes strings to
@@ -511,7 +511,10 @@
 
 // Implementation of encoder/stringifier.
 
-dynamic _defaultToEncodable(dynamic object) => object.toJson();
+dynamic _defaultToEncodable(dynamic object) {
+  /* object.toJson(); */
+  throw "dynamic lookup of toJson is not supported";
+}
 
 /**
  * JSON encoder that traverses an object structure and writes JSON source.
@@ -537,7 +540,7 @@
   static const int CHAR_u = 0x75;
 
   /** List of objects currently being traversed. Used to detect cycles. */
-  final List _seen = new List();
+  final List<Object> _seen = new List<Object>();
   /** Function called for each un-encodable object encountered. */
   final _ToEncodable _toEncodable;
 
@@ -551,7 +554,7 @@
   /** Append a single character, given by its code point, to the JSON output. */
   void writeCharCode(int charCode);
   /** Write a number to the JSON output. */
-  void writeNumber(num number);
+  // void writeNumber(num number);
 
   // ('0' + x) or ('a' + x - 10)
   static int hexDigit(int x) => x < 10 ? 48 + x : 87 + x;
@@ -663,11 +666,12 @@
    * Returns true if the value is one of these types, and false if not.
    * If a value is both a [List] and a [Map], it's serialized as a [List].
    */
-  bool writeJsonValue(object) {
-    if (object is num) {
-      if (!object.isFinite) return false;
+  bool writeJsonValue(Object object) {
+    if (/* object is num */ false) {
+      /* if (!object.isFinite) return false;
       writeNumber(object);
-      return true;
+      return true;*/
+      return false;
     } else if (identical(object, true)) {
       writeString('true');
       return true;
@@ -682,12 +686,12 @@
       writeStringContent(object);
       writeString('"');
       return true;
-    } else if (object is List) {
+    } else if (object is List<Object>) {
       _checkCycle(object);
       writeList(object);
       _removeSeen(object);
       return true;
-    } else if (object is Map) {
+    } else if (object is Map<String, Object>) {
       _checkCycle(object);
       // writeMap can fail if keys are not all strings.
       var success = writeMap(object);
@@ -699,7 +703,7 @@
   }
 
   /** Serialize a [List]. */
-  void writeList(List list) {
+  void writeList(List<Object> list) {
     writeString('[');
     if (list.length > 0) {
       writeObject(list[0]);
@@ -712,12 +716,12 @@
   }
 
   /** Serialize a [Map]. */
-  bool writeMap(Map map) {
+  bool writeMap(Map<String, Object> map) {
     if (map.isEmpty) {
       writeString("{}");
       return true;
     }
-    List keyValueList = new List(map.length * 2);
+    List<Object> keyValueList = new List<Object>(map.length * 2);
     int i = 0;
     bool allStringKeys = true;
     map.forEach((key, value) {
@@ -756,7 +760,7 @@
    */
   void writeIndentation(int indentLevel);
 
-  void writeList(List list) {
+  void writeList(List<Object> list) {
     if (list.isEmpty) {
       writeString('[]');
     } else {
@@ -776,12 +780,12 @@
     }
   }
 
-  bool writeMap(Map map) {
+  bool writeMap(Map<String, Object> map) {
     if (map.isEmpty) {
       writeString("{}");
       return true;
     }
-    List keyValueList = new List(map.length * 2);
+    List<Object> keyValueList = new List<Object>(map.length * 2);
     int i = 0;
     bool allStringKeys = true;
     map.forEach((key, value) {
@@ -853,11 +857,11 @@
     }
     stringifier.writeObject(object);
   }
-
+/*
   void writeNumber(num number) {
     _sink.write(number.toString());
   }
-
+*/
   void writeString(String string) {
     _sink.write(string);
   }
@@ -938,9 +942,10 @@
     index = 0;
   }
 
+  /*
   void writeNumber(num number) {
     writeAsciiString(number.toString());
-  }
+  }*/
 
   /** Write a string that is known to not have non-ASCII characters. */
   void writeAsciiString(String string) {
@@ -1030,7 +1035,7 @@
 class _JsonUtf8StringifierPretty extends _JsonUtf8Stringifier
     with _JsonPrettyPrintMixin {
   final List<int> indent;
-  _JsonUtf8StringifierPretty(toEncodable(o), this.indent, bufferSize,
+  _JsonUtf8StringifierPretty(toEncodable(o), this.indent, int bufferSize,
       void addChunk(Uint8List buffer, int start, int end))
       : super(toEncodable, bufferSize, addChunk);
 
diff --git a/sdk/lib/convert/utf.dart b/sdk/lib/convert/utf.dart
index cc58642..4e1331e 100644
--- a/sdk/lib/convert/utf.dart
+++ b/sdk/lib/convert/utf.dart
@@ -87,10 +87,10 @@
    * If [start] and [end] are provided, only the substring
    * `string.substring(start, end)` is converted.
    */
-  List<int> convert(String string, [int start = 0, int end]) {
+  List<int> convert(String string, [int start = 0, int end = -1]) {
     int stringLength = string.length;
+    if (end == -1) end = stringLength;
     RangeError.checkValidRange(start, end, stringLength);
-    if (end == null) end = stringLength;
     int length = end - start;
     if (length == 0) return new Uint8List(0);
     // Create a new encoder with a length that is guaranteed to be big enough.
@@ -330,7 +330,7 @@
    * If the [codeUnits] start with the encoding of a
    * [UNICODE_BOM_CHARACTER_RUNE], that character is discarded.
    */
-  String convert(List<int> codeUnits, [int start = 0, int end]) {
+  String convert(List<int> codeUnits, [int start = 0, int end = -1]) {
     // Allow the implementation to intercept and specialize based on the type
     // of codeUnits.
     String result = _convertIntercepted(_allowMalformed, codeUnits, start, end);
@@ -339,8 +339,8 @@
     }
 
     int length = codeUnits.length;
+    if (end == -1) end = length;
     RangeError.checkValidRange(start, end, length);
-    if (end == null) end = length;
     StringBuffer buffer = new StringBuffer();
     _Utf8Decoder decoder = new _Utf8Decoder(buffer, _allowMalformed);
     decoder.convert(codeUnits, start, end);
@@ -454,7 +454,7 @@
     _expectedUnits = 0;
     _extraUnits = 0;
 
-    int scanOneByteCharacters(units, int from) {
+    int scanOneByteCharacters(List<int> units, int from) {
       final to = endIndex;
       final mask = _ONE_BYTE_LIMIT;
       for (var i = from; i < to; i++) {
diff --git a/sdk/lib/core/double.dart b/sdk/lib/core/double.dart
index 88b6aa1..5780591 100644
--- a/sdk/lib/core/double.dart
+++ b/sdk/lib/core/double.dart
@@ -29,29 +29,13 @@
   static const double MIN_POSITIVE = 5e-324;
   static const double MAX_FINITE = 1.7976931348623157e+308;
 
-  double remainder(num other);
-
-  /** Addition operator. */
-  double operator +(num other);
-
-  /** Subtraction operator. */
-  double operator -(num other);
-
-  /** Multiplication operator. */
-  double operator *(num other);
-
-  double operator %(num other);
-
-  /** Division operator. */
-  double operator /(num other);
-
   /**
    * Truncating division operator.
    *
    * The result of the truncating division `a ~/ b` is equivalent to
    * `(a / b).truncate()`.
    */
-  int operator ~/(num other);
+  int operator ~/(double other);
 
   /** Negate operator. */
   double operator -();
diff --git a/sdk/lib/core/errors.dart b/sdk/lib/core/errors.dart
index 3db4318..0929a9e 100644
--- a/sdk/lib/core/errors.dart
+++ b/sdk/lib/core/errors.dart
@@ -193,9 +193,9 @@
  */
 class RangeError extends ArgumentError {
   /** The minimum value that [value] is allowed to assume. */
-  final num start;
+  final int start;
   /** The maximum value that [value] is allowed to assume. */
-  final num end;
+  final int end;
 
   // TODO(lrn): This constructor should be called only with string values.
   // It currently isn't in all cases.
@@ -203,9 +203,7 @@
    * Create a new [RangeError] with the given [message].
    */
   RangeError(var message)
-      : start = null,
-        end = null,
-        super(message);
+      : super(message);
 
   /**
    * Create a new [RangeError] with a message for the given [value].
@@ -214,11 +212,9 @@
    * invalid value, and the [message] can override the default error
    * description.
    */
-  RangeError.value(num value, [String name, String message])
-      : start = null,
-        end = null,
-        super.value(
-            value, name, (message != null) ? message : "Value not in range");
+  RangeError.value(int value, [String name, String message])
+      : super.value(
+            "${value}", name, (message != null) ? message : "Value not in range");
 
   /**
    * Create a new [RangeError] for a value being outside the valid range.
@@ -234,7 +230,7 @@
    * invalid value, and the [message] can override the default error
    * description.
    */
-  RangeError.range(num invalidValue, int minValue, int maxValue,
+  RangeError.range(int invalidValue, int minValue, int maxValue,
       [String name, String message])
       : start = minValue,
         end = maxValue,
diff --git a/sdk/lib/core/num.dart b/sdk/lib/core/num.dart
index 1db2508..06ecebe 100644
--- a/sdk/lib/core/num.dart
+++ b/sdk/lib/core/num.dart
@@ -42,7 +42,7 @@
    * Use [compareTo] for a comparison that distinguishes zero and minus zero,
    * and that considers NaN values as equal.
    */
-  bool operator ==(Object other);
+  bool operator == (num other);
 
   /**
    * Returns a hash code for a numerical value.
diff --git a/sdk/lib/core/object.dart b/sdk/lib/core/object.dart
index 34a0084..0375362 100644
--- a/sdk/lib/core/object.dart
+++ b/sdk/lib/core/object.dart
@@ -49,29 +49,29 @@
    *  * Transitive: For all objects `o1`, `o2`, and `o3`, if `o1 == o2` and
    *    `o2 == o3` are true, then `o1 == o3` must be true.
    *
-   * The method should also be consistent over time, 
+   * The method should also be consistent over time,
    * so whether two objects are equal should only change
    * if at least one of the objects was modified.
    *
    * If a subclass overrides the equality operator it should override
    * the [hashCode] method as well to maintain consistency.
    */
-  external bool operator ==(other);
+  external bool operator ==(Object other);
 
   /**
    * The hash code for this object.
    *
    * A hash code is a single integer which represents the state of the object
    * that affects [==] comparisons.
-   * 
-   * All objects have hash codes. 
-   * The default hash code represents only the identity of the object, 
+   *
+   * All objects have hash codes.
+   * The default hash code represents only the identity of the object,
    * the same way as the default [==] implementation only considers objects
    * equal if they are identical (see [identityHashCode]).
-   * 
-   * If [==] is overridden to use the object state instead, 
-   * the hash code must also be changed to represent that state. 
-   * 
+   *
+   * If [==] is overridden to use the object state instead,
+   * the hash code must also be changed to represent that state.
+   *
    * Hash codes must be the same for objects that are equal to each other
    * according to [==].
    * The hash code of an object should only change if the object changes
@@ -79,12 +79,12 @@
    * There are no further requirements for the hash codes.
    * They need not be consistent between executions of the same program
    * and there are no distribution guarantees.
-   * 
+   *
    * Objects that are not equal are allowed to have the same hash code,
    * it is even technically allowed that all instances have the same hash code,
    * but if clashes happen too often, it may reduce the efficiency of hash-based
    * data structures like [HashSet] or [HashMap].
-   * 
+   *
    * If a subclass overrides [hashCode], it should override the
    * [==] operator as well to maintain consistency.
    */
diff --git a/sdk/lib/developer/extension.dart b/sdk/lib/developer/extension.dart
index 1ec7424..2903c7d 100644
--- a/sdk/lib/developer/extension.dart
+++ b/sdk/lib/developer/extension.dart
@@ -19,7 +19,7 @@
   /// the JSON-RPC message [result] will be inlined directly.
   ServiceExtensionResponse.result(String result)
       : _result = result,
-        _errorCode = null,
+        _errorCode = -1,
         _errorDetail = null {
     if (_result is! String) {
       throw new ArgumentError.value(_result, "result", "Must be a String");
@@ -80,25 +80,22 @@
   }
 
   static _validateErrorCode(int errorCode) {
-    if (errorCode is! int) {
-      throw new ArgumentError.value(errorCode, "errorCode", "Must be an int");
-    }
     if (errorCode == invalidParams) {
       return;
     }
     if ((errorCode >= extensionErrorMin) && (errorCode <= extensionErrorMax)) {
       return;
     }
-    throw new ArgumentError.value(errorCode, "errorCode", "Out of range");
+    throw new ArgumentError.value("${errorCode}", "errorCode", "Out of range");
   }
 
-  bool _isError() => (_errorCode != null) && (_errorDetail != null);
+  bool _isError() => (_errorCode != -1) && (_errorDetail != null);
 
   String _toString() {
     if (_result != null) {
       return _result;
     } else {
-      assert(_errorCode != null);
+      assert(_errorCode != -1);
       assert(_errorDetail != null);
       return JSON.encode({
         'code': _errorCode,
diff --git a/sdk/lib/internal/iterable.dart b/sdk/lib/internal/iterable.dart
index 843b5d5..fff7a71 100644
--- a/sdk/lib/internal/iterable.dart
+++ b/sdk/lib/internal/iterable.dart
@@ -61,7 +61,7 @@
     return elementAt(0);
   }
 
-  bool contains(Object element) {
+  bool contains(E element) {
     int length = this.length;
     for (int i = 0; i < length; i++) {
       if (elementAt(i) == element) return true;
@@ -199,7 +199,7 @@
     return value;
   }
 
-  Iterable<E> skip(int count) => new SubListIterable<E>(this, count, null);
+  Iterable<E> skip(int count) => new SubListIterable<E>(this, count, SubListIterable.UpToLength);
 
   Iterable<E> skipWhile(bool test(E element)) => super.skipWhile(test);
 
@@ -232,12 +232,14 @@
 class SubListIterable<E> extends ListIterable<E> {
   final Iterable<E> _iterable; // Has efficient length and elementAt.
   final int _start;
-  /** If null, represents the length of the iterable. */
+  /** If -1, represents the length of the iterable. */
   final int _endOrLength;
 
+  static const int UpToLength = -1;
+
   SubListIterable(this._iterable, this._start, this._endOrLength) {
     RangeError.checkNotNegative(_start, "start");
-    if (_endOrLength != null) {
+    if (_endOrLength != UpToLength) {
       RangeError.checkNotNegative(_endOrLength, "end");
       if (_start > _endOrLength) {
         throw new RangeError.range(_start, 0, _endOrLength, "start");
@@ -247,7 +249,7 @@
 
   int get _endIndex {
     int length = _iterable.length;
-    if (_endOrLength == null || _endOrLength > length) return length;
+    if (_endOrLength == UpToLength || _endOrLength > length) return length;
     return _endOrLength;
   }
 
@@ -260,7 +262,7 @@
   int get length {
     int length = _iterable.length;
     if (_start >= length) return 0;
-    if (_endOrLength == null || _endOrLength >= length) {
+    if (_endOrLength == UpToLength || _endOrLength >= length) {
       return length - _start;
     }
     return _endOrLength - _start;
@@ -277,7 +279,7 @@
   Iterable<E> skip(int count) {
     RangeError.checkNotNegative(count, "count");
     int newStart = _start + count;
-    if (_endOrLength != null && newStart >= _endOrLength) {
+    if (_endOrLength != UpToLength && newStart >= _endOrLength) {
       return new EmptyIterable<E>();
     }
     return new SubListIterable<E>(_iterable, newStart, _endOrLength);
@@ -285,7 +287,7 @@
 
   Iterable<E> take(int count) {
     RangeError.checkNotNegative(count, "count");
-    if (_endOrLength == null) {
+    if (_endOrLength == UpToLength) {
       return new SubListIterable<E>(_iterable, _start, _start + count);
     } else {
       int newEnd = _start + count;
@@ -297,7 +299,7 @@
   List<E> toList({bool growable: true}) {
     int start = _start;
     int end = _iterable.length;
-    if (_endOrLength != null && _endOrLength < end) end = _endOrLength;
+    if (_endOrLength != UpToLength && _endOrLength < end) end = _endOrLength;
     int length = end - start;
     if (length < 0) length = 0;
     List<E> result =
@@ -697,7 +699,7 @@
     throw new RangeError.range(index, 0, 0, "index");
   }
 
-  bool contains(Object element) => false;
+  bool contains(E element) => false;
 
   bool every(bool test(E element)) => true;
 
diff --git a/sdk/lib/internal/list.dart b/sdk/lib/internal/list.dart
index 624a3ed..353dc86 100644
--- a/sdk/lib/internal/list.dart
+++ b/sdk/lib/internal/list.dart
@@ -220,7 +220,7 @@
   E operator [](Object key) => containsKey(key) ? _values[key] : null;
   int get length => _values.length;
 
-  Iterable<E> get values => new SubListIterable<E>(_values, 0, null);
+  Iterable<E> get values => new SubListIterable<E>(_values, 0, SubListIterable.UpToLength);
   Iterable<int> get keys => new _ListIndicesIterable(_values);
 
   bool get isEmpty => _values.isEmpty;
diff --git a/tools/compile_platform.dart b/tools/compile_platform.dart
new file mode 100644
index 0000000..e771fc5
--- /dev/null
+++ b/tools/compile_platform.dart
@@ -0,0 +1,83 @@
+#!/usr/bin/env dart
+// Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+/// Command line tool to merge the SDK libraries and our patch files.
+/// This is currently designed as an offline tool, but we could automate it.
+
+import 'dart:io';
+import 'dart:isolate' show RawReceivePort;
+import 'dart:async';
+import 'dart:math' as math;
+
+import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/src/generated/sdk.dart';
+import 'package:path/path.dart' as path;
+
+import 'package:front_end/src/fasta/fasta.dart'
+    show compilePlatform, writeDepsFile;
+
+/// Set of input files that were read by this script to generate patched SDK.
+/// We will dump it out into the depfile for ninja to use.
+///
+/// For more information see GN and Ninja references:
+///    https://chromium.googlesource.com/chromium/src/+/56807c6cb383140af0c03da8f6731d77785d7160/tools/gn/docs/reference.md#depfile_string_File-name-for-input-dependencies-for-actions
+///    https://ninja-build.org/manual.html#_depfile
+///
+final deps = new Set<Uri>();
+
+/// Create [File] object from the given path and register it as a dependency.
+File getInputFile(String path, {canBeMissing: false}) {
+  final file = new File(path);
+  if (!file.existsSync()) {
+    if (!canBeMissing) throw "patch_sdk.dart expects all inputs to exist";
+    return null;
+  }
+  deps.add(Uri.base.resolveUri(file.uri));
+  return file;
+}
+
+/// Read the given file synchronously as a string and register this path as
+/// a dependency.
+String readInputFile(String path, {canBeMissing: false}) =>
+    getInputFile(path, canBeMissing: canBeMissing)?.readAsStringSync();
+
+Future main(List<String> argv) async {
+  var port = new RawReceivePort();
+  try {
+    await _main(argv);
+  } finally {
+    port.close();
+  }
+}
+
+Future _main(List<String> argv) async {
+  var base = path.fromUri(Platform.script);
+  var dartDir = path.dirname(path.dirname(path.absolute(base)));
+
+  var sdkDir = argv[0];
+  var packagesFile = argv[1];
+  var platformOut = argv[2];
+
+  Uri platform = Uri.base.resolveUri(new Uri.file('${platformOut}.tmp'));
+  Uri platformFinalLocation = Uri.base.resolveUri(new Uri.file(platformOut));
+
+  Uri packages = Uri.base.resolveUri(new Uri.file(packagesFile));
+  await compilePlatform(
+      Uri.base.resolveUri(new Uri.directory(sdkDir)), platform,
+      packages: packages, verbose: false);
+
+  final platformDeps = new File.fromUri(Uri.base.resolveUri(new Uri.file('${platformOut}.tmp.d'))).readAsStringSync();
+
+
+  await writeDepsFile(Platform.script,
+      Uri.base.resolveUri(new Uri.file("$platformOut.d")),
+      platformFinalLocation,
+      packages: packages,
+      platform: platform,
+      extraDependencies: new Set.from(platformDeps.split(': ')[1].split(' ').where((s) => s.isNotEmpty).map((path) => new Uri.file(path))),
+      verbose: false);
+
+  await new File.fromUri(platform).rename(platformFinalLocation.toFilePath());
+}
diff --git a/tools/compile_platform.py b/tools/compile_platform.py
new file mode 100755
index 0000000..fd5e8bc
--- /dev/null
+++ b/tools/compile_platform.py
@@ -0,0 +1,56 @@
+#!/usr/bin/env python
+# Copyright (c) 2016, the Dart project authors.  Please see the AUTHORS file
+# for details. All rights reserved. Use of this source code is governed by a
+# BSD-style license that can be found in the LICENSE file.
+
+import argparse
+import os
+import subprocess
+import sys
+import utils
+
+usage = """compile_platform.py [options]"""
+
+def DisplayBootstrapWarning():
+  print """\
+
+
+WARNING: Your system cannot run the checked-in Dart SDK. Using the
+bootstrap Dart executable will make debug builds slow.
+Please see the Wiki for instructions on replacing the checked-in Dart SDK.
+
+https://github.com/dart-lang/sdk/wiki/The-checked-in-SDK-in-tools
+
+"""
+
+def BuildArguments():
+  result = argparse.ArgumentParser(usage=usage)
+  result.add_argument("-q", "--quiet",
+                      help="emit no output",
+                      default=False,
+                      action="store_true")
+  result.add_argument("--dart-executable",
+                      help="dart executable",
+                      default=None)
+  return result
+
+def main():
+  # Parse the options.
+  parser = BuildArguments()
+  (options, args) = parser.parse_known_args()
+  if utils.CheckedInSdkCheckExecutable():
+    options.dart_executable = utils.CheckedInSdkExecutable()
+  elif options.dart_executable is not None:
+    if not options.quiet:
+      DisplayBootstrapWarning()
+    options.dart_executable = os.path.abspath(options.dart_executable)
+  else:
+    print >> sys.stderr, 'ERROR: cannot locate dart executable'
+    return -1
+  dart_file = os.path.join(os.path.dirname(__file__), 'compile_platform.dart')
+  subprocess.check_call(
+      [options.dart_executable, '--checked', dart_file] + args)
+  return 0
+
+if __name__ == '__main__':
+  sys.exit(main())
diff --git a/vipunen/bin/inferrer.dart b/vipunen/bin/inferrer.dart
index f13a902..26f687b 100644
--- a/vipunen/bin/inferrer.dart
+++ b/vipunen/bin/inferrer.dart
@@ -11,6 +11,12 @@
 
 enum TypeKind { Concrete, Subclass, Interface, Closure, Bottom }
 
+enum SelectorKind {
+  Method,
+  Getter,
+  Setter,
+}
+
 class Selector {
   final SelectorKind kind;
   final Name name;
@@ -68,12 +74,6 @@
   }
 }
 
-enum SelectorKind {
-  Method,
-  Getter,
-  Setter,
-}
-
 enum NumericType { Int, Double }
 
 class ResolvedTarget {
diff --git a/vipunen/patched_sdk/lib/_blink/dartium/_blink_dartium.dart b/vipunen/patched_sdk/lib/_blink/dartium/_blink_dartium.dart
new file mode 100644
index 0000000..4fd6341
--- /dev/null
+++ b/vipunen/patched_sdk/lib/_blink/dartium/_blink_dartium.dart
@@ -0,0 +1,38117 @@
+/* Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
+ * for details. All rights reserved. Use of this source code is governed by a
+ * BSD-style license that can be found in the LICENSE file.
+ *
+ * DO NOT EDIT
+ * Auto-generated _blink library.
+ */
+library dart.dom._blink;
+
+import 'dart:async';
+import 'dart:js' as js;
+import 'dart:html' show DomException;
+import 'dart:_internal' as internal;
+
+// This is a place to put custom renames if we need them.
+final resolverMap = {};
+
+dynamic resolver(String s) {
+  if (s == "ANGLEInstancedArrays") return BlinkANGLEInstancedArrays.instance;
+  if (s == "AbstractWorker") return BlinkAbstractWorker.instance;
+  if (s == "AnalyserNode") return BlinkAnalyserNode.instance;
+  if (s == "Animation") return BlinkAnimation.instance;
+  if (s == "AnimationEffectReadOnly")
+    return BlinkAnimationEffectReadOnly.instance;
+  if (s == "AnimationEffectTiming") return BlinkAnimationEffectTiming.instance;
+  if (s == "AnimationEvent") return BlinkAnimationEvent.instance;
+  if (s == "AnimationPlayerEvent") return BlinkAnimationPlayerEvent.instance;
+  if (s == "AnimationTimeline") return BlinkAnimationTimeline.instance;
+  if (s == "AppBannerPromptResult") return BlinkAppBannerPromptResult.instance;
+  if (s == "ApplicationCache") return BlinkApplicationCache.instance;
+  if (s == "ApplicationCacheErrorEvent")
+    return BlinkApplicationCacheErrorEvent.instance;
+  if (s == "ArrayBuffer") return BlinkArrayBuffer.instance;
+  if (s == "ArrayBufferView") return BlinkArrayBufferView.instance;
+  if (s == "Attr") return BlinkAttr.instance;
+  if (s == "AudioBuffer") return BlinkAudioBuffer.instance;
+  if (s == "AudioBufferCallback") return BlinkAudioBufferCallback.instance;
+  if (s == "AudioBufferSourceNode") return BlinkAudioBufferSourceNode.instance;
+  if (s == "AudioContext") return BlinkAudioContext.instance;
+  if (s == "AudioDestinationNode") return BlinkAudioDestinationNode.instance;
+  if (s == "AudioListener") return BlinkAudioListener.instance;
+  if (s == "AudioNode") return BlinkAudioNode.instance;
+  if (s == "AudioParam") return BlinkAudioParam.instance;
+  if (s == "AudioProcessingEvent") return BlinkAudioProcessingEvent.instance;
+  if (s == "AudioSourceNode") return BlinkAudioSourceNode.instance;
+  if (s == "AudioTrack") return BlinkAudioTrack.instance;
+  if (s == "AudioTrackList") return BlinkAudioTrackList.instance;
+  if (s == "AutocompleteErrorEvent")
+    return BlinkAutocompleteErrorEvent.instance;
+  if (s == "BarProp") return BlinkBarProp.instance;
+  if (s == "BatteryManager") return BlinkBatteryManager.instance;
+  if (s == "BeforeInstallPromptEvent")
+    return BlinkBeforeInstallPromptEvent.instance;
+  if (s == "BeforeUnloadEvent") return BlinkBeforeUnloadEvent.instance;
+  if (s == "BiquadFilterNode") return BlinkBiquadFilterNode.instance;
+  if (s == "Blob") return BlinkBlob.instance;
+  if (s == "Bluetooth") return BlinkBluetooth.instance;
+  if (s == "BluetoothDevice") return BlinkBluetoothDevice.instance;
+  if (s == "BluetoothGATTCharacteristic")
+    return BlinkBluetoothGATTCharacteristic.instance;
+  if (s == "BluetoothGATTRemoteServer")
+    return BlinkBluetoothGATTRemoteServer.instance;
+  if (s == "BluetoothGATTService") return BlinkBluetoothGATTService.instance;
+  if (s == "BluetoothUUID") return BlinkBluetoothUUID.instance;
+  if (s == "Body") return BlinkBody.instance;
+  if (s == "CDATASection") return BlinkCDATASection.instance;
+  if (s == "CHROMIUMSubscribeUniform")
+    return BlinkCHROMIUMSubscribeUniform.instance;
+  if (s == "CHROMIUMValuebuffer") return BlinkCHROMIUMValuebuffer.instance;
+  if (s == "CSS") return BlinkCSS.instance;
+  if (s == "CSSCharsetRule") return BlinkCSSCharsetRule.instance;
+  if (s == "CSSFontFaceRule") return BlinkCSSFontFaceRule.instance;
+  if (s == "CSSGroupingRule") return BlinkCSSGroupingRule.instance;
+  if (s == "CSSImportRule") return BlinkCSSImportRule.instance;
+  if (s == "CSSKeyframeRule") return BlinkCSSKeyframeRule.instance;
+  if (s == "CSSKeyframesRule") return BlinkCSSKeyframesRule.instance;
+  if (s == "CSSMediaRule") return BlinkCSSMediaRule.instance;
+  if (s == "CSSPageRule") return BlinkCSSPageRule.instance;
+  if (s == "CSSRule") return BlinkCSSRule.instance;
+  if (s == "CSSRuleList") return BlinkCSSRuleList.instance;
+  if (s == "CSSStyleDeclaration") return BlinkCSSStyleDeclaration.instance;
+  if (s == "CSSStyleRule") return BlinkCSSStyleRule.instance;
+  if (s == "CSSStyleSheet") return BlinkCSSStyleSheet.instance;
+  if (s == "CSSSupportsRule") return BlinkCSSSupportsRule.instance;
+  if (s == "CSSViewportRule") return BlinkCSSViewportRule.instance;
+  if (s == "Cache") return BlinkCache.instance;
+  if (s == "CacheStorage") return BlinkCacheStorage.instance;
+  if (s == "CanvasGradient") return BlinkCanvasGradient.instance;
+  if (s == "CanvasPathMethods") return BlinkCanvasPathMethods.instance;
+  if (s == "CanvasPattern") return BlinkCanvasPattern.instance;
+  if (s == "CanvasRenderingContext2D")
+    return BlinkCanvasRenderingContext2D.instance;
+  if (s == "ChannelMergerNode") return BlinkChannelMergerNode.instance;
+  if (s == "ChannelSplitterNode") return BlinkChannelSplitterNode.instance;
+  if (s == "CharacterData") return BlinkCharacterData.instance;
+  if (s == "ChildNode") return BlinkChildNode.instance;
+  if (s == "CircularGeofencingRegion")
+    return BlinkCircularGeofencingRegion.instance;
+  if (s == "Client") return BlinkClient.instance;
+  if (s == "ClientRect") return BlinkClientRect.instance;
+  if (s == "ClientRectList") return BlinkClientRectList.instance;
+  if (s == "Clients") return BlinkClients.instance;
+  if (s == "ClipboardEvent") return BlinkClipboardEvent.instance;
+  if (s == "CloseEvent") return BlinkCloseEvent.instance;
+  if (s == "Comment") return BlinkComment.instance;
+  if (s == "CompositionEvent") return BlinkCompositionEvent.instance;
+  if (s == "CompositorProxy") return BlinkCompositorProxy.instance;
+  if (s == "CompositorWorker") return BlinkCompositorWorker.instance;
+  if (s == "CompositorWorkerGlobalScope")
+    return BlinkCompositorWorkerGlobalScope.instance;
+  if (s == "Console") return BlinkConsole.instance;
+  if (s == "ConsoleBase") return BlinkConsoleBase.instance;
+  if (s == "ConvolverNode") return BlinkConvolverNode.instance;
+  if (s == "Coordinates") return BlinkCoordinates.instance;
+  if (s == "Credential") return BlinkCredential.instance;
+  if (s == "CredentialsContainer") return BlinkCredentialsContainer.instance;
+  if (s == "CrossOriginConnectEvent")
+    return BlinkCrossOriginConnectEvent.instance;
+  if (s == "CrossOriginServiceWorkerClient")
+    return BlinkCrossOriginServiceWorkerClient.instance;
+  if (s == "Crypto") return BlinkCrypto.instance;
+  if (s == "CryptoKey") return BlinkCryptoKey.instance;
+  if (s == "CustomEvent") return BlinkCustomEvent.instance;
+  if (s == "DOMError") return BlinkDOMError.instance;
+  if (s == "DOMException") return BlinkDOMException.instance;
+  if (s == "DOMFileSystem") return BlinkDOMFileSystem.instance;
+  if (s == "DOMFileSystemSync") return BlinkDOMFileSystemSync.instance;
+  if (s == "DOMImplementation") return BlinkDOMImplementation.instance;
+  if (s == "DOMMatrix") return BlinkDOMMatrix.instance;
+  if (s == "DOMMatrixReadOnly") return BlinkDOMMatrixReadOnly.instance;
+  if (s == "DOMParser") return BlinkDOMParser.instance;
+  if (s == "DOMPoint") return BlinkDOMPoint.instance;
+  if (s == "DOMPointReadOnly") return BlinkDOMPointReadOnly.instance;
+  if (s == "DOMRect") return BlinkDOMRect.instance;
+  if (s == "DOMRectReadOnly") return BlinkDOMRectReadOnly.instance;
+  if (s == "DOMSettableTokenList") return BlinkDOMSettableTokenList.instance;
+  if (s == "DOMStringList") return BlinkDOMStringList.instance;
+  if (s == "DOMStringMap") return BlinkDOMStringMap.instance;
+  if (s == "DOMTokenList") return BlinkDOMTokenList.instance;
+  if (s == "DataTransfer") return BlinkDataTransfer.instance;
+  if (s == "DataTransferItem") return BlinkDataTransferItem.instance;
+  if (s == "DataTransferItemList") return BlinkDataTransferItemList.instance;
+  if (s == "DataView") return BlinkDataView.instance;
+  if (s == "Database") return BlinkDatabase.instance;
+  if (s == "DatabaseCallback") return BlinkDatabaseCallback.instance;
+  if (s == "DedicatedWorkerGlobalScope")
+    return BlinkDedicatedWorkerGlobalScope.instance;
+  if (s == "DefaultSessionStartEvent")
+    return BlinkDefaultSessionStartEvent.instance;
+  if (s == "DelayNode") return BlinkDelayNode.instance;
+  if (s == "DeprecatedStorageInfo") return BlinkDeprecatedStorageInfo.instance;
+  if (s == "DeprecatedStorageQuota")
+    return BlinkDeprecatedStorageQuota.instance;
+  if (s == "DeviceAcceleration") return BlinkDeviceAcceleration.instance;
+  if (s == "DeviceLightEvent") return BlinkDeviceLightEvent.instance;
+  if (s == "DeviceMotionEvent") return BlinkDeviceMotionEvent.instance;
+  if (s == "DeviceOrientationEvent")
+    return BlinkDeviceOrientationEvent.instance;
+  if (s == "DeviceRotationRate") return BlinkDeviceRotationRate.instance;
+  if (s == "DirectoryEntry") return BlinkDirectoryEntry.instance;
+  if (s == "DirectoryEntrySync") return BlinkDirectoryEntrySync.instance;
+  if (s == "DirectoryReader") return BlinkDirectoryReader.instance;
+  if (s == "DirectoryReaderSync") return BlinkDirectoryReaderSync.instance;
+  if (s == "Document") return BlinkDocument.instance;
+  if (s == "DocumentFragment") return BlinkDocumentFragment.instance;
+  if (s == "DocumentType") return BlinkDocumentType.instance;
+  if (s == "DynamicsCompressorNode")
+    return BlinkDynamicsCompressorNode.instance;
+  if (s == "EXTBlendMinMax") return BlinkEXTBlendMinMax.instance;
+  if (s == "EXTFragDepth") return BlinkEXTFragDepth.instance;
+  if (s == "EXTShaderTextureLOD") return BlinkEXTShaderTextureLOD.instance;
+  if (s == "EXTTextureFilterAnisotropic")
+    return BlinkEXTTextureFilterAnisotropic.instance;
+  if (s == "EXTsRGB") return BlinkEXTsRGB.instance;
+  if (s == "EffectModel") return BlinkEffectModel.instance;
+  if (s == "Element") return BlinkElement.instance;
+  if (s == "EntriesCallback") return BlinkEntriesCallback.instance;
+  if (s == "Entry") return BlinkEntry.instance;
+  if (s == "EntryCallback") return BlinkEntryCallback.instance;
+  if (s == "EntrySync") return BlinkEntrySync.instance;
+  if (s == "ErrorCallback") return BlinkErrorCallback.instance;
+  if (s == "ErrorEvent") return BlinkErrorEvent.instance;
+  if (s == "Event") return BlinkEvent.instance;
+  if (s == "EventListener") return BlinkEventListener.instance;
+  if (s == "EventSource") return BlinkEventSource.instance;
+  if (s == "EventTarget") return BlinkEventTarget.instance;
+  if (s == "ExtendableEvent") return BlinkExtendableEvent.instance;
+  if (s == "FederatedCredential") return BlinkFederatedCredential.instance;
+  if (s == "FetchEvent") return BlinkFetchEvent.instance;
+  if (s == "File") return BlinkFile.instance;
+  if (s == "FileCallback") return BlinkFileCallback.instance;
+  if (s == "FileEntry") return BlinkFileEntry.instance;
+  if (s == "FileEntrySync") return BlinkFileEntrySync.instance;
+  if (s == "FileError") return BlinkFileError.instance;
+  if (s == "FileList") return BlinkFileList.instance;
+  if (s == "FileReader") return BlinkFileReader.instance;
+  if (s == "FileReaderSync") return BlinkFileReaderSync.instance;
+  if (s == "FileSystemCallback") return BlinkFileSystemCallback.instance;
+  if (s == "FileWriter") return BlinkFileWriter.instance;
+  if (s == "FileWriterCallback") return BlinkFileWriterCallback.instance;
+  if (s == "FileWriterSync") return BlinkFileWriterSync.instance;
+  if (s == "Float32Array") return BlinkFloat32Array.instance;
+  if (s == "Float64Array") return BlinkFloat64Array.instance;
+  if (s == "FocusEvent") return BlinkFocusEvent.instance;
+  if (s == "FontFace") return BlinkFontFace.instance;
+  if (s == "FontFaceSet") return BlinkFontFaceSet.instance;
+  if (s == "FontFaceSetForEachCallback")
+    return BlinkFontFaceSetForEachCallback.instance;
+  if (s == "FontFaceSetLoadEvent") return BlinkFontFaceSetLoadEvent.instance;
+  if (s == "FormData") return BlinkFormData.instance;
+  if (s == "FrameRequestCallback") return BlinkFrameRequestCallback.instance;
+  if (s == "GainNode") return BlinkGainNode.instance;
+  if (s == "Gamepad") return BlinkGamepad.instance;
+  if (s == "GamepadButton") return BlinkGamepadButton.instance;
+  if (s == "GamepadEvent") return BlinkGamepadEvent.instance;
+  if (s == "GamepadList") return BlinkGamepadList.instance;
+  if (s == "Geofencing") return BlinkGeofencing.instance;
+  if (s == "GeofencingEvent") return BlinkGeofencingEvent.instance;
+  if (s == "GeofencingRegion") return BlinkGeofencingRegion.instance;
+  if (s == "Geolocation") return BlinkGeolocation.instance;
+  if (s == "Geoposition") return BlinkGeoposition.instance;
+  if (s == "GlobalEventHandlers") return BlinkGlobalEventHandlers.instance;
+  if (s == "HMDVRDevice") return BlinkHMDVRDevice.instance;
+  if (s == "HTMLAllCollection") return BlinkHTMLAllCollection.instance;
+  if (s == "HTMLAnchorElement") return BlinkHTMLAnchorElement.instance;
+  if (s == "HTMLAppletElement") return BlinkHTMLAppletElement.instance;
+  if (s == "HTMLAreaElement") return BlinkHTMLAreaElement.instance;
+  if (s == "HTMLAudioElement") return BlinkHTMLAudioElement.instance;
+  if (s == "HTMLBRElement") return BlinkHTMLBRElement.instance;
+  if (s == "HTMLBaseElement") return BlinkHTMLBaseElement.instance;
+  if (s == "HTMLBodyElement") return BlinkHTMLBodyElement.instance;
+  if (s == "HTMLButtonElement") return BlinkHTMLButtonElement.instance;
+  if (s == "HTMLCanvasElement") return BlinkHTMLCanvasElement.instance;
+  if (s == "HTMLCollection") return BlinkHTMLCollection.instance;
+  if (s == "HTMLContentElement") return BlinkHTMLContentElement.instance;
+  if (s == "HTMLDListElement") return BlinkHTMLDListElement.instance;
+  if (s == "HTMLDataListElement") return BlinkHTMLDataListElement.instance;
+  if (s == "HTMLDetailsElement") return BlinkHTMLDetailsElement.instance;
+  if (s == "HTMLDialogElement") return BlinkHTMLDialogElement.instance;
+  if (s == "HTMLDirectoryElement") return BlinkHTMLDirectoryElement.instance;
+  if (s == "HTMLDivElement") return BlinkHTMLDivElement.instance;
+  if (s == "HTMLDocument") return BlinkHTMLDocument.instance;
+  if (s == "HTMLElement") return BlinkHTMLElement.instance;
+  if (s == "HTMLEmbedElement") return BlinkHTMLEmbedElement.instance;
+  if (s == "HTMLFieldSetElement") return BlinkHTMLFieldSetElement.instance;
+  if (s == "HTMLFontElement") return BlinkHTMLFontElement.instance;
+  if (s == "HTMLFormControlsCollection")
+    return BlinkHTMLFormControlsCollection.instance;
+  if (s == "HTMLFormElement") return BlinkHTMLFormElement.instance;
+  if (s == "HTMLFrameElement") return BlinkHTMLFrameElement.instance;
+  if (s == "HTMLFrameSetElement") return BlinkHTMLFrameSetElement.instance;
+  if (s == "HTMLHRElement") return BlinkHTMLHRElement.instance;
+  if (s == "HTMLHeadElement") return BlinkHTMLHeadElement.instance;
+  if (s == "HTMLHeadingElement") return BlinkHTMLHeadingElement.instance;
+  if (s == "HTMLHtmlElement") return BlinkHTMLHtmlElement.instance;
+  if (s == "HTMLIFrameElement") return BlinkHTMLIFrameElement.instance;
+  if (s == "HTMLImageElement") return BlinkHTMLImageElement.instance;
+  if (s == "HTMLInputElement") return BlinkHTMLInputElement.instance;
+  if (s == "HTMLKeygenElement") return BlinkHTMLKeygenElement.instance;
+  if (s == "HTMLLIElement") return BlinkHTMLLIElement.instance;
+  if (s == "HTMLLabelElement") return BlinkHTMLLabelElement.instance;
+  if (s == "HTMLLegendElement") return BlinkHTMLLegendElement.instance;
+  if (s == "HTMLLinkElement") return BlinkHTMLLinkElement.instance;
+  if (s == "HTMLMapElement") return BlinkHTMLMapElement.instance;
+  if (s == "HTMLMarqueeElement") return BlinkHTMLMarqueeElement.instance;
+  if (s == "HTMLMediaElement") return BlinkHTMLMediaElement.instance;
+  if (s == "HTMLMenuElement") return BlinkHTMLMenuElement.instance;
+  if (s == "HTMLMenuItemElement") return BlinkHTMLMenuItemElement.instance;
+  if (s == "HTMLMetaElement") return BlinkHTMLMetaElement.instance;
+  if (s == "HTMLMeterElement") return BlinkHTMLMeterElement.instance;
+  if (s == "HTMLModElement") return BlinkHTMLModElement.instance;
+  if (s == "HTMLOListElement") return BlinkHTMLOListElement.instance;
+  if (s == "HTMLObjectElement") return BlinkHTMLObjectElement.instance;
+  if (s == "HTMLOptGroupElement") return BlinkHTMLOptGroupElement.instance;
+  if (s == "HTMLOptionElement") return BlinkHTMLOptionElement.instance;
+  if (s == "HTMLOptionsCollection") return BlinkHTMLOptionsCollection.instance;
+  if (s == "HTMLOutputElement") return BlinkHTMLOutputElement.instance;
+  if (s == "HTMLParagraphElement") return BlinkHTMLParagraphElement.instance;
+  if (s == "HTMLParamElement") return BlinkHTMLParamElement.instance;
+  if (s == "HTMLPictureElement") return BlinkHTMLPictureElement.instance;
+  if (s == "HTMLPreElement") return BlinkHTMLPreElement.instance;
+  if (s == "HTMLProgressElement") return BlinkHTMLProgressElement.instance;
+  if (s == "HTMLQuoteElement") return BlinkHTMLQuoteElement.instance;
+  if (s == "HTMLScriptElement") return BlinkHTMLScriptElement.instance;
+  if (s == "HTMLSelectElement") return BlinkHTMLSelectElement.instance;
+  if (s == "HTMLShadowElement") return BlinkHTMLShadowElement.instance;
+  if (s == "HTMLSourceElement") return BlinkHTMLSourceElement.instance;
+  if (s == "HTMLSpanElement") return BlinkHTMLSpanElement.instance;
+  if (s == "HTMLStyleElement") return BlinkHTMLStyleElement.instance;
+  if (s == "HTMLTableCaptionElement")
+    return BlinkHTMLTableCaptionElement.instance;
+  if (s == "HTMLTableCellElement") return BlinkHTMLTableCellElement.instance;
+  if (s == "HTMLTableColElement") return BlinkHTMLTableColElement.instance;
+  if (s == "HTMLTableElement") return BlinkHTMLTableElement.instance;
+  if (s == "HTMLTableRowElement") return BlinkHTMLTableRowElement.instance;
+  if (s == "HTMLTableSectionElement")
+    return BlinkHTMLTableSectionElement.instance;
+  if (s == "HTMLTemplateElement") return BlinkHTMLTemplateElement.instance;
+  if (s == "HTMLTextAreaElement") return BlinkHTMLTextAreaElement.instance;
+  if (s == "HTMLTitleElement") return BlinkHTMLTitleElement.instance;
+  if (s == "HTMLTrackElement") return BlinkHTMLTrackElement.instance;
+  if (s == "HTMLUListElement") return BlinkHTMLUListElement.instance;
+  if (s == "HTMLUnknownElement") return BlinkHTMLUnknownElement.instance;
+  if (s == "HTMLVideoElement") return BlinkHTMLVideoElement.instance;
+  if (s == "HashChangeEvent") return BlinkHashChangeEvent.instance;
+  if (s == "Headers") return BlinkHeaders.instance;
+  if (s == "History") return BlinkHistory.instance;
+  if (s == "IDBCursor") return BlinkIDBCursor.instance;
+  if (s == "IDBCursorWithValue") return BlinkIDBCursorWithValue.instance;
+  if (s == "IDBDatabase") return BlinkIDBDatabase.instance;
+  if (s == "IDBFactory") return BlinkIDBFactory.instance;
+  if (s == "IDBIndex") return BlinkIDBIndex.instance;
+  if (s == "IDBKeyRange") return BlinkIDBKeyRange.instance;
+  if (s == "IDBObjectStore") return BlinkIDBObjectStore.instance;
+  if (s == "IDBOpenDBRequest") return BlinkIDBOpenDBRequest.instance;
+  if (s == "IDBRequest") return BlinkIDBRequest.instance;
+  if (s == "IDBTransaction") return BlinkIDBTransaction.instance;
+  if (s == "IDBVersionChangeEvent") return BlinkIDBVersionChangeEvent.instance;
+  if (s == "ImageBitmap") return BlinkImageBitmap.instance;
+  if (s == "ImageData") return BlinkImageData.instance;
+  if (s == "InjectedScriptHost") return BlinkInjectedScriptHost.instance;
+  if (s == "InputDevice") return BlinkInputDevice.instance;
+  if (s == "Int16Array") return BlinkInt16Array.instance;
+  if (s == "Int32Array") return BlinkInt32Array.instance;
+  if (s == "Int8Array") return BlinkInt8Array.instance;
+  if (s == "Iterator") return BlinkIterator.instance;
+  if (s == "KeyboardEvent") return BlinkKeyboardEvent.instance;
+  if (s == "KeyframeEffect") return BlinkKeyframeEffect.instance;
+  if (s == "Location") return BlinkLocation.instance;
+  if (s == "MIDIAccess") return BlinkMIDIAccess.instance;
+  if (s == "MIDIConnectionEvent") return BlinkMIDIConnectionEvent.instance;
+  if (s == "MIDIInput") return BlinkMIDIInput.instance;
+  if (s == "MIDIInputMap") return BlinkMIDIInputMap.instance;
+  if (s == "MIDIMessageEvent") return BlinkMIDIMessageEvent.instance;
+  if (s == "MIDIOutput") return BlinkMIDIOutput.instance;
+  if (s == "MIDIOutputMap") return BlinkMIDIOutputMap.instance;
+  if (s == "MIDIPort") return BlinkMIDIPort.instance;
+  if (s == "MediaController") return BlinkMediaController.instance;
+  if (s == "MediaDeviceInfo") return BlinkMediaDeviceInfo.instance;
+  if (s == "MediaDevices") return BlinkMediaDevices.instance;
+  if (s == "MediaElementAudioSourceNode")
+    return BlinkMediaElementAudioSourceNode.instance;
+  if (s == "MediaEncryptedEvent") return BlinkMediaEncryptedEvent.instance;
+  if (s == "MediaError") return BlinkMediaError.instance;
+  if (s == "MediaKeyError") return BlinkMediaKeyError.instance;
+  if (s == "MediaKeyEvent") return BlinkMediaKeyEvent.instance;
+  if (s == "MediaKeyMessageEvent") return BlinkMediaKeyMessageEvent.instance;
+  if (s == "MediaKeySession") return BlinkMediaKeySession.instance;
+  if (s == "MediaKeyStatusMap") return BlinkMediaKeyStatusMap.instance;
+  if (s == "MediaKeySystemAccess") return BlinkMediaKeySystemAccess.instance;
+  if (s == "MediaKeys") return BlinkMediaKeys.instance;
+  if (s == "MediaList") return BlinkMediaList.instance;
+  if (s == "MediaQueryList") return BlinkMediaQueryList.instance;
+  if (s == "MediaQueryListEvent") return BlinkMediaQueryListEvent.instance;
+  if (s == "MediaSession") return BlinkMediaSession.instance;
+  if (s == "MediaSource") return BlinkMediaSource.instance;
+  if (s == "MediaStream") return BlinkMediaStream.instance;
+  if (s == "MediaStreamAudioDestinationNode")
+    return BlinkMediaStreamAudioDestinationNode.instance;
+  if (s == "MediaStreamAudioSourceNode")
+    return BlinkMediaStreamAudioSourceNode.instance;
+  if (s == "MediaStreamEvent") return BlinkMediaStreamEvent.instance;
+  if (s == "MediaStreamTrack") return BlinkMediaStreamTrack.instance;
+  if (s == "MediaStreamTrackEvent") return BlinkMediaStreamTrackEvent.instance;
+  if (s == "MediaStreamTrackSourcesCallback")
+    return BlinkMediaStreamTrackSourcesCallback.instance;
+  if (s == "MemoryInfo") return BlinkMemoryInfo.instance;
+  if (s == "MessageChannel") return BlinkMessageChannel.instance;
+  if (s == "MessageEvent") return BlinkMessageEvent.instance;
+  if (s == "MessagePort") return BlinkMessagePort.instance;
+  if (s == "Metadata") return BlinkMetadata.instance;
+  if (s == "MetadataCallback") return BlinkMetadataCallback.instance;
+  if (s == "MimeType") return BlinkMimeType.instance;
+  if (s == "MimeTypeArray") return BlinkMimeTypeArray.instance;
+  if (s == "MouseEvent") return BlinkMouseEvent.instance;
+  if (s == "MutationCallback") return BlinkMutationCallback.instance;
+  if (s == "MutationObserver") return BlinkMutationObserver.instance;
+  if (s == "MutationRecord") return BlinkMutationRecord.instance;
+  if (s == "NamedNodeMap") return BlinkNamedNodeMap.instance;
+  if (s == "Navigator") return BlinkNavigator.instance;
+  if (s == "NavigatorCPU") return BlinkNavigatorCPU.instance;
+  if (s == "NavigatorID") return BlinkNavigatorID.instance;
+  if (s == "NavigatorLanguage") return BlinkNavigatorLanguage.instance;
+  if (s == "NavigatorOnLine") return BlinkNavigatorOnLine.instance;
+  if (s == "NavigatorStorageUtils") return BlinkNavigatorStorageUtils.instance;
+  if (s == "NavigatorUserMediaError")
+    return BlinkNavigatorUserMediaError.instance;
+  if (s == "NavigatorUserMediaErrorCallback")
+    return BlinkNavigatorUserMediaErrorCallback.instance;
+  if (s == "NavigatorUserMediaSuccessCallback")
+    return BlinkNavigatorUserMediaSuccessCallback.instance;
+  if (s == "NetworkInformation") return BlinkNetworkInformation.instance;
+  if (s == "Node") return BlinkNode.instance;
+  if (s == "NodeFilter") return BlinkNodeFilter.instance;
+  if (s == "NodeIterator") return BlinkNodeIterator.instance;
+  if (s == "NodeList") return BlinkNodeList.instance;
+  if (s == "NonDocumentTypeChildNode")
+    return BlinkNonDocumentTypeChildNode.instance;
+  if (s == "NonElementParentNode") return BlinkNonElementParentNode.instance;
+  if (s == "Notification") return BlinkNotification.instance;
+  if (s == "NotificationEvent") return BlinkNotificationEvent.instance;
+  if (s == "NotificationPermissionCallback")
+    return BlinkNotificationPermissionCallback.instance;
+  if (s == "OESElementIndexUint") return BlinkOESElementIndexUint.instance;
+  if (s == "OESStandardDerivatives")
+    return BlinkOESStandardDerivatives.instance;
+  if (s == "OESTextureFloat") return BlinkOESTextureFloat.instance;
+  if (s == "OESTextureFloatLinear") return BlinkOESTextureFloatLinear.instance;
+  if (s == "OESTextureHalfFloat") return BlinkOESTextureHalfFloat.instance;
+  if (s == "OESTextureHalfFloatLinear")
+    return BlinkOESTextureHalfFloatLinear.instance;
+  if (s == "OESVertexArrayObject") return BlinkOESVertexArrayObject.instance;
+  if (s == "OfflineAudioCompletionEvent")
+    return BlinkOfflineAudioCompletionEvent.instance;
+  if (s == "OfflineAudioContext") return BlinkOfflineAudioContext.instance;
+  if (s == "OscillatorNode") return BlinkOscillatorNode.instance;
+  if (s == "PagePopupController") return BlinkPagePopupController.instance;
+  if (s == "PageTransitionEvent") return BlinkPageTransitionEvent.instance;
+  if (s == "PannerNode") return BlinkPannerNode.instance;
+  if (s == "ParentNode") return BlinkParentNode.instance;
+  if (s == "PasswordCredential") return BlinkPasswordCredential.instance;
+  if (s == "Path2D") return BlinkPath2D.instance;
+  if (s == "Performance") return BlinkPerformance.instance;
+  if (s == "PerformanceCompositeTiming")
+    return BlinkPerformanceCompositeTiming.instance;
+  if (s == "PerformanceEntry") return BlinkPerformanceEntry.instance;
+  if (s == "PerformanceMark") return BlinkPerformanceMark.instance;
+  if (s == "PerformanceMeasure") return BlinkPerformanceMeasure.instance;
+  if (s == "PerformanceNavigation") return BlinkPerformanceNavigation.instance;
+  if (s == "PerformanceRenderTiming")
+    return BlinkPerformanceRenderTiming.instance;
+  if (s == "PerformanceResourceTiming")
+    return BlinkPerformanceResourceTiming.instance;
+  if (s == "PerformanceTiming") return BlinkPerformanceTiming.instance;
+  if (s == "PeriodicSyncEvent") return BlinkPeriodicSyncEvent.instance;
+  if (s == "PeriodicSyncManager") return BlinkPeriodicSyncManager.instance;
+  if (s == "PeriodicSyncRegistration")
+    return BlinkPeriodicSyncRegistration.instance;
+  if (s == "PeriodicWave") return BlinkPeriodicWave.instance;
+  if (s == "PermissionStatus") return BlinkPermissionStatus.instance;
+  if (s == "Permissions") return BlinkPermissions.instance;
+  if (s == "Plugin") return BlinkPlugin.instance;
+  if (s == "PluginArray") return BlinkPluginArray.instance;
+  if (s == "PluginPlaceholderElement")
+    return BlinkPluginPlaceholderElement.instance;
+  if (s == "PointerEvent") return BlinkPointerEvent.instance;
+  if (s == "PopStateEvent") return BlinkPopStateEvent.instance;
+  if (s == "PositionCallback") return BlinkPositionCallback.instance;
+  if (s == "PositionError") return BlinkPositionError.instance;
+  if (s == "PositionErrorCallback") return BlinkPositionErrorCallback.instance;
+  if (s == "PositionSensorVRDevice")
+    return BlinkPositionSensorVRDevice.instance;
+  if (s == "Presentation") return BlinkPresentation.instance;
+  if (s == "PresentationAvailability")
+    return BlinkPresentationAvailability.instance;
+  if (s == "PresentationSession") return BlinkPresentationSession.instance;
+  if (s == "ProcessingInstruction") return BlinkProcessingInstruction.instance;
+  if (s == "ProgressEvent") return BlinkProgressEvent.instance;
+  if (s == "PromiseRejectionEvent") return BlinkPromiseRejectionEvent.instance;
+  if (s == "PushEvent") return BlinkPushEvent.instance;
+  if (s == "PushManager") return BlinkPushManager.instance;
+  if (s == "PushMessageData") return BlinkPushMessageData.instance;
+  if (s == "PushSubscription") return BlinkPushSubscription.instance;
+  if (s == "RTCDTMFSender") return BlinkRTCDTMFSender.instance;
+  if (s == "RTCDTMFToneChangeEvent")
+    return BlinkRTCDTMFToneChangeEvent.instance;
+  if (s == "RTCDataChannel") return BlinkRTCDataChannel.instance;
+  if (s == "RTCDataChannelEvent") return BlinkRTCDataChannelEvent.instance;
+  if (s == "RTCErrorCallback") return BlinkRTCErrorCallback.instance;
+  if (s == "RTCIceCandidate") return BlinkRTCIceCandidate.instance;
+  if (s == "RTCIceCandidateEvent") return BlinkRTCIceCandidateEvent.instance;
+  if (s == "RTCPeerConnection") return BlinkRTCPeerConnection.instance;
+  if (s == "RTCSessionDescription") return BlinkRTCSessionDescription.instance;
+  if (s == "RTCSessionDescriptionCallback")
+    return BlinkRTCSessionDescriptionCallback.instance;
+  if (s == "RTCStatsCallback") return BlinkRTCStatsCallback.instance;
+  if (s == "RTCStatsReport") return BlinkRTCStatsReport.instance;
+  if (s == "RTCStatsResponse") return BlinkRTCStatsResponse.instance;
+  if (s == "RadioNodeList") return BlinkRadioNodeList.instance;
+  if (s == "Range") return BlinkRange.instance;
+  if (s == "ReadableByteStream") return BlinkReadableByteStream.instance;
+  if (s == "ReadableByteStreamReader")
+    return BlinkReadableByteStreamReader.instance;
+  if (s == "ReadableStream") return BlinkReadableStream.instance;
+  if (s == "ReadableStreamReader") return BlinkReadableStreamReader.instance;
+  if (s == "RelatedEvent") return BlinkRelatedEvent.instance;
+  if (s == "Request") return BlinkRequest.instance;
+  if (s == "RequestAnimationFrameCallback")
+    return BlinkRequestAnimationFrameCallback.instance;
+  if (s == "ResourceProgressEvent") return BlinkResourceProgressEvent.instance;
+  if (s == "Response") return BlinkResponse.instance;
+  if (s == "SQLError") return BlinkSQLError.instance;
+  if (s == "SQLResultSet") return BlinkSQLResultSet.instance;
+  if (s == "SQLResultSetRowList") return BlinkSQLResultSetRowList.instance;
+  if (s == "SQLStatementCallback") return BlinkSQLStatementCallback.instance;
+  if (s == "SQLStatementErrorCallback")
+    return BlinkSQLStatementErrorCallback.instance;
+  if (s == "SQLTransaction") return BlinkSQLTransaction.instance;
+  if (s == "SQLTransactionCallback")
+    return BlinkSQLTransactionCallback.instance;
+  if (s == "SQLTransactionErrorCallback")
+    return BlinkSQLTransactionErrorCallback.instance;
+  if (s == "SVGAElement") return BlinkSVGAElement.instance;
+  if (s == "SVGAngle") return BlinkSVGAngle.instance;
+  if (s == "SVGAnimateElement") return BlinkSVGAnimateElement.instance;
+  if (s == "SVGAnimateMotionElement")
+    return BlinkSVGAnimateMotionElement.instance;
+  if (s == "SVGAnimateTransformElement")
+    return BlinkSVGAnimateTransformElement.instance;
+  if (s == "SVGAnimatedAngle") return BlinkSVGAnimatedAngle.instance;
+  if (s == "SVGAnimatedBoolean") return BlinkSVGAnimatedBoolean.instance;
+  if (s == "SVGAnimatedEnumeration")
+    return BlinkSVGAnimatedEnumeration.instance;
+  if (s == "SVGAnimatedInteger") return BlinkSVGAnimatedInteger.instance;
+  if (s == "SVGAnimatedLength") return BlinkSVGAnimatedLength.instance;
+  if (s == "SVGAnimatedLengthList") return BlinkSVGAnimatedLengthList.instance;
+  if (s == "SVGAnimatedNumber") return BlinkSVGAnimatedNumber.instance;
+  if (s == "SVGAnimatedNumberList") return BlinkSVGAnimatedNumberList.instance;
+  if (s == "SVGAnimatedPreserveAspectRatio")
+    return BlinkSVGAnimatedPreserveAspectRatio.instance;
+  if (s == "SVGAnimatedRect") return BlinkSVGAnimatedRect.instance;
+  if (s == "SVGAnimatedString") return BlinkSVGAnimatedString.instance;
+  if (s == "SVGAnimatedTransformList")
+    return BlinkSVGAnimatedTransformList.instance;
+  if (s == "SVGAnimationElement") return BlinkSVGAnimationElement.instance;
+  if (s == "SVGCircleElement") return BlinkSVGCircleElement.instance;
+  if (s == "SVGClipPathElement") return BlinkSVGClipPathElement.instance;
+  if (s == "SVGComponentTransferFunctionElement")
+    return BlinkSVGComponentTransferFunctionElement.instance;
+  if (s == "SVGCursorElement") return BlinkSVGCursorElement.instance;
+  if (s == "SVGDefsElement") return BlinkSVGDefsElement.instance;
+  if (s == "SVGDescElement") return BlinkSVGDescElement.instance;
+  if (s == "SVGDiscardElement") return BlinkSVGDiscardElement.instance;
+  if (s == "SVGElement") return BlinkSVGElement.instance;
+  if (s == "SVGEllipseElement") return BlinkSVGEllipseElement.instance;
+  if (s == "SVGFEBlendElement") return BlinkSVGFEBlendElement.instance;
+  if (s == "SVGFEColorMatrixElement")
+    return BlinkSVGFEColorMatrixElement.instance;
+  if (s == "SVGFEComponentTransferElement")
+    return BlinkSVGFEComponentTransferElement.instance;
+  if (s == "SVGFECompositeElement") return BlinkSVGFECompositeElement.instance;
+  if (s == "SVGFEConvolveMatrixElement")
+    return BlinkSVGFEConvolveMatrixElement.instance;
+  if (s == "SVGFEDiffuseLightingElement")
+    return BlinkSVGFEDiffuseLightingElement.instance;
+  if (s == "SVGFEDisplacementMapElement")
+    return BlinkSVGFEDisplacementMapElement.instance;
+  if (s == "SVGFEDistantLightElement")
+    return BlinkSVGFEDistantLightElement.instance;
+  if (s == "SVGFEDropShadowElement")
+    return BlinkSVGFEDropShadowElement.instance;
+  if (s == "SVGFEFloodElement") return BlinkSVGFEFloodElement.instance;
+  if (s == "SVGFEFuncAElement") return BlinkSVGFEFuncAElement.instance;
+  if (s == "SVGFEFuncBElement") return BlinkSVGFEFuncBElement.instance;
+  if (s == "SVGFEFuncGElement") return BlinkSVGFEFuncGElement.instance;
+  if (s == "SVGFEFuncRElement") return BlinkSVGFEFuncRElement.instance;
+  if (s == "SVGFEGaussianBlurElement")
+    return BlinkSVGFEGaussianBlurElement.instance;
+  if (s == "SVGFEImageElement") return BlinkSVGFEImageElement.instance;
+  if (s == "SVGFEMergeElement") return BlinkSVGFEMergeElement.instance;
+  if (s == "SVGFEMergeNodeElement") return BlinkSVGFEMergeNodeElement.instance;
+  if (s == "SVGFEMorphologyElement")
+    return BlinkSVGFEMorphologyElement.instance;
+  if (s == "SVGFEOffsetElement") return BlinkSVGFEOffsetElement.instance;
+  if (s == "SVGFEPointLightElement")
+    return BlinkSVGFEPointLightElement.instance;
+  if (s == "SVGFESpecularLightingElement")
+    return BlinkSVGFESpecularLightingElement.instance;
+  if (s == "SVGFESpotLightElement") return BlinkSVGFESpotLightElement.instance;
+  if (s == "SVGFETileElement") return BlinkSVGFETileElement.instance;
+  if (s == "SVGFETurbulenceElement")
+    return BlinkSVGFETurbulenceElement.instance;
+  if (s == "SVGFilterElement") return BlinkSVGFilterElement.instance;
+  if (s == "SVGFilterPrimitiveStandardAttributes")
+    return BlinkSVGFilterPrimitiveStandardAttributes.instance;
+  if (s == "SVGFitToViewBox") return BlinkSVGFitToViewBox.instance;
+  if (s == "SVGForeignObjectElement")
+    return BlinkSVGForeignObjectElement.instance;
+  if (s == "SVGGElement") return BlinkSVGGElement.instance;
+  if (s == "SVGGeometryElement") return BlinkSVGGeometryElement.instance;
+  if (s == "SVGGradientElement") return BlinkSVGGradientElement.instance;
+  if (s == "SVGGraphicsElement") return BlinkSVGGraphicsElement.instance;
+  if (s == "SVGImageElement") return BlinkSVGImageElement.instance;
+  if (s == "SVGLength") return BlinkSVGLength.instance;
+  if (s == "SVGLengthList") return BlinkSVGLengthList.instance;
+  if (s == "SVGLineElement") return BlinkSVGLineElement.instance;
+  if (s == "SVGLinearGradientElement")
+    return BlinkSVGLinearGradientElement.instance;
+  if (s == "SVGMPathElement") return BlinkSVGMPathElement.instance;
+  if (s == "SVGMarkerElement") return BlinkSVGMarkerElement.instance;
+  if (s == "SVGMaskElement") return BlinkSVGMaskElement.instance;
+  if (s == "SVGMatrix") return BlinkSVGMatrix.instance;
+  if (s == "SVGMetadataElement") return BlinkSVGMetadataElement.instance;
+  if (s == "SVGNumber") return BlinkSVGNumber.instance;
+  if (s == "SVGNumberList") return BlinkSVGNumberList.instance;
+  if (s == "SVGPathElement") return BlinkSVGPathElement.instance;
+  if (s == "SVGPathSeg") return BlinkSVGPathSeg.instance;
+  if (s == "SVGPathSegArcAbs") return BlinkSVGPathSegArcAbs.instance;
+  if (s == "SVGPathSegArcRel") return BlinkSVGPathSegArcRel.instance;
+  if (s == "SVGPathSegClosePath") return BlinkSVGPathSegClosePath.instance;
+  if (s == "SVGPathSegCurvetoCubicAbs")
+    return BlinkSVGPathSegCurvetoCubicAbs.instance;
+  if (s == "SVGPathSegCurvetoCubicRel")
+    return BlinkSVGPathSegCurvetoCubicRel.instance;
+  if (s == "SVGPathSegCurvetoCubicSmoothAbs")
+    return BlinkSVGPathSegCurvetoCubicSmoothAbs.instance;
+  if (s == "SVGPathSegCurvetoCubicSmoothRel")
+    return BlinkSVGPathSegCurvetoCubicSmoothRel.instance;
+  if (s == "SVGPathSegCurvetoQuadraticAbs")
+    return BlinkSVGPathSegCurvetoQuadraticAbs.instance;
+  if (s == "SVGPathSegCurvetoQuadraticRel")
+    return BlinkSVGPathSegCurvetoQuadraticRel.instance;
+  if (s == "SVGPathSegCurvetoQuadraticSmoothAbs")
+    return BlinkSVGPathSegCurvetoQuadraticSmoothAbs.instance;
+  if (s == "SVGPathSegCurvetoQuadraticSmoothRel")
+    return BlinkSVGPathSegCurvetoQuadraticSmoothRel.instance;
+  if (s == "SVGPathSegLinetoAbs") return BlinkSVGPathSegLinetoAbs.instance;
+  if (s == "SVGPathSegLinetoHorizontalAbs")
+    return BlinkSVGPathSegLinetoHorizontalAbs.instance;
+  if (s == "SVGPathSegLinetoHorizontalRel")
+    return BlinkSVGPathSegLinetoHorizontalRel.instance;
+  if (s == "SVGPathSegLinetoRel") return BlinkSVGPathSegLinetoRel.instance;
+  if (s == "SVGPathSegLinetoVerticalAbs")
+    return BlinkSVGPathSegLinetoVerticalAbs.instance;
+  if (s == "SVGPathSegLinetoVerticalRel")
+    return BlinkSVGPathSegLinetoVerticalRel.instance;
+  if (s == "SVGPathSegList") return BlinkSVGPathSegList.instance;
+  if (s == "SVGPathSegMovetoAbs") return BlinkSVGPathSegMovetoAbs.instance;
+  if (s == "SVGPathSegMovetoRel") return BlinkSVGPathSegMovetoRel.instance;
+  if (s == "SVGPatternElement") return BlinkSVGPatternElement.instance;
+  if (s == "SVGPoint") return BlinkSVGPoint.instance;
+  if (s == "SVGPointList") return BlinkSVGPointList.instance;
+  if (s == "SVGPolygonElement") return BlinkSVGPolygonElement.instance;
+  if (s == "SVGPolylineElement") return BlinkSVGPolylineElement.instance;
+  if (s == "SVGPreserveAspectRatio")
+    return BlinkSVGPreserveAspectRatio.instance;
+  if (s == "SVGRadialGradientElement")
+    return BlinkSVGRadialGradientElement.instance;
+  if (s == "SVGRect") return BlinkSVGRect.instance;
+  if (s == "SVGRectElement") return BlinkSVGRectElement.instance;
+  if (s == "SVGSVGElement") return BlinkSVGSVGElement.instance;
+  if (s == "SVGScriptElement") return BlinkSVGScriptElement.instance;
+  if (s == "SVGSetElement") return BlinkSVGSetElement.instance;
+  if (s == "SVGStopElement") return BlinkSVGStopElement.instance;
+  if (s == "SVGStringList") return BlinkSVGStringList.instance;
+  if (s == "SVGStyleElement") return BlinkSVGStyleElement.instance;
+  if (s == "SVGSwitchElement") return BlinkSVGSwitchElement.instance;
+  if (s == "SVGSymbolElement") return BlinkSVGSymbolElement.instance;
+  if (s == "SVGTSpanElement") return BlinkSVGTSpanElement.instance;
+  if (s == "SVGTests") return BlinkSVGTests.instance;
+  if (s == "SVGTextContentElement") return BlinkSVGTextContentElement.instance;
+  if (s == "SVGTextElement") return BlinkSVGTextElement.instance;
+  if (s == "SVGTextPathElement") return BlinkSVGTextPathElement.instance;
+  if (s == "SVGTextPositioningElement")
+    return BlinkSVGTextPositioningElement.instance;
+  if (s == "SVGTitleElement") return BlinkSVGTitleElement.instance;
+  if (s == "SVGTransform") return BlinkSVGTransform.instance;
+  if (s == "SVGTransformList") return BlinkSVGTransformList.instance;
+  if (s == "SVGURIReference") return BlinkSVGURIReference.instance;
+  if (s == "SVGUnitTypes") return BlinkSVGUnitTypes.instance;
+  if (s == "SVGUseElement") return BlinkSVGUseElement.instance;
+  if (s == "SVGViewElement") return BlinkSVGViewElement.instance;
+  if (s == "SVGViewSpec") return BlinkSVGViewSpec.instance;
+  if (s == "SVGZoomAndPan") return BlinkSVGZoomAndPan.instance;
+  if (s == "SVGZoomEvent") return BlinkSVGZoomEvent.instance;
+  if (s == "Screen") return BlinkScreen.instance;
+  if (s == "ScreenOrientation") return BlinkScreenOrientation.instance;
+  if (s == "ScriptProcessorNode") return BlinkScriptProcessorNode.instance;
+  if (s == "ScrollState") return BlinkScrollState.instance;
+  if (s == "SecurityPolicyViolationEvent")
+    return BlinkSecurityPolicyViolationEvent.instance;
+  if (s == "Selection") return BlinkSelection.instance;
+  if (s == "ServicePort") return BlinkServicePort.instance;
+  if (s == "ServicePortCollection") return BlinkServicePortCollection.instance;
+  if (s == "ServicePortConnectEvent")
+    return BlinkServicePortConnectEvent.instance;
+  if (s == "ServiceWorker") return BlinkServiceWorker.instance;
+  if (s == "ServiceWorkerContainer")
+    return BlinkServiceWorkerContainer.instance;
+  if (s == "ServiceWorkerGlobalScope")
+    return BlinkServiceWorkerGlobalScope.instance;
+  if (s == "ServiceWorkerMessageEvent")
+    return BlinkServiceWorkerMessageEvent.instance;
+  if (s == "ServiceWorkerRegistration")
+    return BlinkServiceWorkerRegistration.instance;
+  if (s == "ShadowRoot") return BlinkShadowRoot.instance;
+  if (s == "SharedArrayBuffer") return BlinkSharedArrayBuffer.instance;
+  if (s == "SharedWorker") return BlinkSharedWorker.instance;
+  if (s == "SharedWorkerGlobalScope")
+    return BlinkSharedWorkerGlobalScope.instance;
+  if (s == "SourceBuffer") return BlinkSourceBuffer.instance;
+  if (s == "SourceBufferList") return BlinkSourceBufferList.instance;
+  if (s == "SourceInfo") return BlinkSourceInfo.instance;
+  if (s == "SpeechGrammar") return BlinkSpeechGrammar.instance;
+  if (s == "SpeechGrammarList") return BlinkSpeechGrammarList.instance;
+  if (s == "SpeechRecognition") return BlinkSpeechRecognition.instance;
+  if (s == "SpeechRecognitionAlternative")
+    return BlinkSpeechRecognitionAlternative.instance;
+  if (s == "SpeechRecognitionError")
+    return BlinkSpeechRecognitionError.instance;
+  if (s == "SpeechRecognitionEvent")
+    return BlinkSpeechRecognitionEvent.instance;
+  if (s == "SpeechRecognitionResult")
+    return BlinkSpeechRecognitionResult.instance;
+  if (s == "SpeechRecognitionResultList")
+    return BlinkSpeechRecognitionResultList.instance;
+  if (s == "SpeechSynthesis") return BlinkSpeechSynthesis.instance;
+  if (s == "SpeechSynthesisEvent") return BlinkSpeechSynthesisEvent.instance;
+  if (s == "SpeechSynthesisUtterance")
+    return BlinkSpeechSynthesisUtterance.instance;
+  if (s == "SpeechSynthesisVoice") return BlinkSpeechSynthesisVoice.instance;
+  if (s == "StashedMessagePort") return BlinkStashedMessagePort.instance;
+  if (s == "StashedPortCollection") return BlinkStashedPortCollection.instance;
+  if (s == "StereoPannerNode") return BlinkStereoPannerNode.instance;
+  if (s == "Storage") return BlinkStorage.instance;
+  if (s == "StorageErrorCallback") return BlinkStorageErrorCallback.instance;
+  if (s == "StorageEvent") return BlinkStorageEvent.instance;
+  if (s == "StorageInfo") return BlinkStorageInfo.instance;
+  if (s == "StorageQuota") return BlinkStorageQuota.instance;
+  if (s == "StorageQuotaCallback") return BlinkStorageQuotaCallback.instance;
+  if (s == "StorageUsageCallback") return BlinkStorageUsageCallback.instance;
+  if (s == "Stream") return BlinkStream.instance;
+  if (s == "StringCallback") return BlinkStringCallback.instance;
+  if (s == "StyleMedia") return BlinkStyleMedia.instance;
+  if (s == "StyleSheet") return BlinkStyleSheet.instance;
+  if (s == "StyleSheetList") return BlinkStyleSheetList.instance;
+  if (s == "SubtleCrypto") return BlinkSubtleCrypto.instance;
+  if (s == "SyncEvent") return BlinkSyncEvent.instance;
+  if (s == "SyncManager") return BlinkSyncManager.instance;
+  if (s == "SyncRegistration") return BlinkSyncRegistration.instance;
+  if (s == "Text") return BlinkText.instance;
+  if (s == "TextEvent") return BlinkTextEvent.instance;
+  if (s == "TextMetrics") return BlinkTextMetrics.instance;
+  if (s == "TextTrack") return BlinkTextTrack.instance;
+  if (s == "TextTrackCue") return BlinkTextTrackCue.instance;
+  if (s == "TextTrackCueList") return BlinkTextTrackCueList.instance;
+  if (s == "TextTrackList") return BlinkTextTrackList.instance;
+  if (s == "TimeRanges") return BlinkTimeRanges.instance;
+  if (s == "TimeoutHandler") return BlinkTimeoutHandler.instance;
+  if (s == "Touch") return BlinkTouch.instance;
+  if (s == "TouchEvent") return BlinkTouchEvent.instance;
+  if (s == "TouchList") return BlinkTouchList.instance;
+  if (s == "TrackDefault") return BlinkTrackDefault.instance;
+  if (s == "TrackDefaultList") return BlinkTrackDefaultList.instance;
+  if (s == "TrackEvent") return BlinkTrackEvent.instance;
+  if (s == "TransitionEvent") return BlinkTransitionEvent.instance;
+  if (s == "TreeWalker") return BlinkTreeWalker.instance;
+  if (s == "UIEvent") return BlinkUIEvent.instance;
+  if (s == "URL") return BlinkURL.instance;
+  if (s == "URLUtils") return BlinkURLUtils.instance;
+  if (s == "URLUtilsReadOnly") return BlinkURLUtilsReadOnly.instance;
+  if (s == "Uint16Array") return BlinkUint16Array.instance;
+  if (s == "Uint32Array") return BlinkUint32Array.instance;
+  if (s == "Uint8Array") return BlinkUint8Array.instance;
+  if (s == "Uint8ClampedArray") return BlinkUint8ClampedArray.instance;
+  if (s == "VRDevice") return BlinkVRDevice.instance;
+  if (s == "VREyeParameters") return BlinkVREyeParameters.instance;
+  if (s == "VRFieldOfView") return BlinkVRFieldOfView.instance;
+  if (s == "VRPositionState") return BlinkVRPositionState.instance;
+  if (s == "VTTCue") return BlinkVTTCue.instance;
+  if (s == "VTTRegion") return BlinkVTTRegion.instance;
+  if (s == "VTTRegionList") return BlinkVTTRegionList.instance;
+  if (s == "ValidityState") return BlinkValidityState.instance;
+  if (s == "VideoPlaybackQuality") return BlinkVideoPlaybackQuality.instance;
+  if (s == "VideoTrack") return BlinkVideoTrack.instance;
+  if (s == "VideoTrackList") return BlinkVideoTrackList.instance;
+  if (s == "VoidCallback") return BlinkVoidCallback.instance;
+  if (s == "WaveShaperNode") return BlinkWaveShaperNode.instance;
+  if (s == "WebGL2RenderingContext")
+    return BlinkWebGL2RenderingContext.instance;
+  if (s == "WebGL2RenderingContextBase")
+    return BlinkWebGL2RenderingContextBase.instance;
+  if (s == "WebGLActiveInfo") return BlinkWebGLActiveInfo.instance;
+  if (s == "WebGLBuffer") return BlinkWebGLBuffer.instance;
+  if (s == "WebGLCompressedTextureATC")
+    return BlinkWebGLCompressedTextureATC.instance;
+  if (s == "WebGLCompressedTextureETC1")
+    return BlinkWebGLCompressedTextureETC1.instance;
+  if (s == "WebGLCompressedTexturePVRTC")
+    return BlinkWebGLCompressedTexturePVRTC.instance;
+  if (s == "WebGLCompressedTextureS3TC")
+    return BlinkWebGLCompressedTextureS3TC.instance;
+  if (s == "WebGLContextEvent") return BlinkWebGLContextEvent.instance;
+  if (s == "WebGLDebugRendererInfo")
+    return BlinkWebGLDebugRendererInfo.instance;
+  if (s == "WebGLDebugShaders") return BlinkWebGLDebugShaders.instance;
+  if (s == "WebGLDepthTexture") return BlinkWebGLDepthTexture.instance;
+  if (s == "WebGLDrawBuffers") return BlinkWebGLDrawBuffers.instance;
+  if (s == "WebGLFramebuffer") return BlinkWebGLFramebuffer.instance;
+  if (s == "WebGLLoseContext") return BlinkWebGLLoseContext.instance;
+  if (s == "WebGLProgram") return BlinkWebGLProgram.instance;
+  if (s == "WebGLQuery") return BlinkWebGLQuery.instance;
+  if (s == "WebGLRenderbuffer") return BlinkWebGLRenderbuffer.instance;
+  if (s == "WebGLRenderingContext") return BlinkWebGLRenderingContext.instance;
+  if (s == "WebGLRenderingContextBase")
+    return BlinkWebGLRenderingContextBase.instance;
+  if (s == "WebGLSampler") return BlinkWebGLSampler.instance;
+  if (s == "WebGLShader") return BlinkWebGLShader.instance;
+  if (s == "WebGLShaderPrecisionFormat")
+    return BlinkWebGLShaderPrecisionFormat.instance;
+  if (s == "WebGLSync") return BlinkWebGLSync.instance;
+  if (s == "WebGLTexture") return BlinkWebGLTexture.instance;
+  if (s == "WebGLTransformFeedback")
+    return BlinkWebGLTransformFeedback.instance;
+  if (s == "WebGLUniformLocation") return BlinkWebGLUniformLocation.instance;
+  if (s == "WebGLVertexArrayObject")
+    return BlinkWebGLVertexArrayObject.instance;
+  if (s == "WebGLVertexArrayObjectOES")
+    return BlinkWebGLVertexArrayObjectOES.instance;
+  if (s == "WebKitCSSMatrix") return BlinkWebKitCSSMatrix.instance;
+  if (s == "WebSocket") return BlinkWebSocket.instance;
+  if (s == "WheelEvent") return BlinkWheelEvent.instance;
+  if (s == "Window") return BlinkWindow.instance;
+  if (s == "WindowBase64") return BlinkWindowBase64.instance;
+  if (s == "WindowClient") return BlinkWindowClient.instance;
+  if (s == "WindowEventHandlers") return BlinkWindowEventHandlers.instance;
+  if (s == "WindowTimers") return BlinkWindowTimers.instance;
+  if (s == "Worker") return BlinkWorker.instance;
+  if (s == "WorkerConsole") return BlinkWorkerConsole.instance;
+  if (s == "WorkerGlobalScope") return BlinkWorkerGlobalScope.instance;
+  if (s == "WorkerLocation") return BlinkWorkerLocation.instance;
+  if (s == "WorkerNavigator") return BlinkWorkerNavigator.instance;
+  if (s == "WorkerPerformance") return BlinkWorkerPerformance.instance;
+  if (s == "XMLDocument") return BlinkXMLDocument.instance;
+  if (s == "XMLHttpRequest") return BlinkXMLHttpRequest.instance;
+  if (s == "XMLHttpRequestEventTarget")
+    return BlinkXMLHttpRequestEventTarget.instance;
+  if (s == "XMLHttpRequestProgressEvent")
+    return BlinkXMLHttpRequestProgressEvent.instance;
+  if (s == "XMLHttpRequestUpload") return BlinkXMLHttpRequestUpload.instance;
+  if (s == "XMLSerializer") return BlinkXMLSerializer.instance;
+  if (s == "XPathEvaluator") return BlinkXPathEvaluator.instance;
+  if (s == "XPathExpression") return BlinkXPathExpression.instance;
+  if (s == "XPathNSResolver") return BlinkXPathNSResolver.instance;
+  if (s == "XPathResult") return BlinkXPathResult.instance;
+  if (s == "XSLTProcessor") return BlinkXSLTProcessor.instance;
+
+  // Failed to find it, check for custom renames
+  dynamic obj = resolverMap[s];
+  if (obj != null) return obj;
+  throw ("No such interface exposed in blink: ${s}");
+}
+
+class BlinkANGLEInstancedArrays {
+  static final instance = new BlinkANGLEInstancedArrays();
+
+  drawArraysInstancedANGLE_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "drawArraysInstancedANGLE", [__arg_0, __arg_1]);
+
+  drawArraysInstancedANGLE_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "drawArraysInstancedANGLE", [__arg_0, __arg_1, __arg_2]);
+
+  drawArraysInstancedANGLE_Callback_4_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "drawArraysInstancedANGLE", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  drawElementsInstancedANGLE_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "drawElementsInstancedANGLE", [__arg_0, __arg_1, __arg_2]);
+
+  drawElementsInstancedANGLE_Callback_4_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "drawElementsInstancedANGLE", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  drawElementsInstancedANGLE_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* ANGLEInstancedArrays */,
+          "drawElementsInstancedANGLE",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  vertexAttribDivisorANGLE_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* ANGLEInstancedArrays */, "vertexAttribDivisorANGLE", []);
+
+  vertexAttribDivisorANGLE_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "vertexAttribDivisorANGLE", [__arg_0]);
+
+  vertexAttribDivisorANGLE_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* ANGLEInstancedArrays */,
+          "vertexAttribDivisorANGLE", [__arg_0, __arg_1]);
+}
+
+class BlinkAbstractWorker {
+  static final instance = new BlinkAbstractWorker();
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AbstractWorker */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AbstractWorker */, "onerror", __arg_0);
+}
+
+class BlinkAnalyserNode extends BlinkAudioNode {
+  static final instance = new BlinkAnalyserNode();
+
+  fftSize_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnalyserNode */, "fftSize");
+
+  fftSize_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnalyserNode */, "fftSize", __arg_0);
+
+  frequencyBinCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnalyserNode */, "frequencyBinCount");
+
+  maxDecibels_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnalyserNode */, "maxDecibels");
+
+  maxDecibels_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnalyserNode */, "maxDecibels", __arg_0);
+
+  minDecibels_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnalyserNode */, "minDecibels");
+
+  minDecibels_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnalyserNode */, "minDecibels", __arg_0);
+
+  smoothingTimeConstant_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* AnalyserNode */, "smoothingTimeConstant");
+
+  smoothingTimeConstant_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnalyserNode */, "smoothingTimeConstant", __arg_0);
+
+  getByteFrequencyData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnalyserNode */, "getByteFrequencyData", []);
+
+  getByteFrequencyData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AnalyserNode */, "getByteFrequencyData", [__arg_0]);
+
+  getByteTimeDomainData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnalyserNode */, "getByteTimeDomainData", []);
+
+  getByteTimeDomainData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AnalyserNode */, "getByteTimeDomainData", [__arg_0]);
+
+  getFloatFrequencyData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnalyserNode */, "getFloatFrequencyData", []);
+
+  getFloatFrequencyData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AnalyserNode */, "getFloatFrequencyData", [__arg_0]);
+
+  getFloatTimeDomainData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnalyserNode */, "getFloatTimeDomainData", []);
+
+  getFloatTimeDomainData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AnalyserNode */, "getFloatTimeDomainData", [__arg_0]);
+}
+
+class BlinkAnimation extends BlinkEventTarget {
+  static final instance = new BlinkAnimation();
+
+  currentTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "currentTime");
+
+  currentTime_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Animation */, "currentTime", __arg_0);
+
+  effect_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Animation */, "effect");
+
+  effect_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Animation */, "effect", __arg_0);
+
+  endClip_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Animation */, "endClip");
+
+  endClip_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Animation */, "endClip", __arg_0);
+
+  finished_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "finished");
+
+  onfinish_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "onfinish");
+
+  onfinish_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Animation */, "onfinish", __arg_0);
+
+  playState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "playState");
+
+  playbackRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "playbackRate");
+
+  playbackRate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Animation */, "playbackRate", __arg_0);
+
+  ready_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Animation */, "ready");
+
+  startClip_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "startClip");
+
+  startClip_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Animation */, "startClip", __arg_0);
+
+  startTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Animation */, "startTime");
+
+  startTime_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Animation */, "startTime", __arg_0);
+
+  cancel_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Animation */, "cancel", []);
+
+  finish_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Animation */, "finish", []);
+
+  pause_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Animation */, "pause", []);
+
+  play_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Animation */, "play", []);
+
+  reverse_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Animation */, "reverse", []);
+}
+
+class BlinkAnimationEffectReadOnly {
+  static final instance = new BlinkAnimationEffectReadOnly();
+
+  computedTiming_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectReadOnly */, "computedTiming");
+
+  timing_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectReadOnly */, "timing");
+}
+
+class BlinkAnimationEffectTiming {
+  static final instance = new BlinkAnimationEffectTiming();
+
+  delay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "delay");
+
+  delay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "delay", __arg_0);
+
+  direction_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "direction");
+
+  direction_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "direction", __arg_0);
+
+  duration_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "duration");
+
+  duration_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "duration", __arg_0);
+
+  easing_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "easing");
+
+  easing_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "easing", __arg_0);
+
+  endDelay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "endDelay");
+
+  endDelay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "endDelay", __arg_0);
+
+  fill_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "fill");
+
+  fill_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "fill", __arg_0);
+
+  iterationStart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "iterationStart");
+
+  iterationStart_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* AnimationEffectTiming */, "iterationStart", __arg_0);
+
+  iterations_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "iterations");
+
+  iterations_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AnimationEffectTiming */, "iterations", __arg_0);
+
+  playbackRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEffectTiming */, "playbackRate");
+
+  playbackRate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnimationEffectTiming */, "playbackRate", __arg_0);
+}
+
+class BlinkAnimationEvent extends BlinkEvent {
+  static final instance = new BlinkAnimationEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("AnimationEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("AnimationEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("AnimationEvent", [__arg_0, __arg_1]);
+
+  animationName_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEvent */, "animationName");
+
+  elapsedTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationEvent */, "elapsedTime");
+}
+
+class BlinkAnimationPlayerEvent extends BlinkEvent {
+  static final instance = new BlinkAnimationPlayerEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("AnimationPlayerEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("AnimationPlayerEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("AnimationPlayerEvent", [__arg_0, __arg_1]);
+
+  currentTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationPlayerEvent */, "currentTime");
+
+  timelineTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationPlayerEvent */, "timelineTime");
+}
+
+class BlinkAnimationTimeline {
+  static final instance = new BlinkAnimationTimeline();
+
+  currentTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationTimeline */, "currentTime");
+
+  currentTime_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnimationTimeline */, "currentTime", __arg_0);
+
+  playbackRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AnimationTimeline */, "playbackRate");
+
+  playbackRate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AnimationTimeline */, "playbackRate", __arg_0);
+
+  getAnimations_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnimationTimeline */, "getAnimations", []);
+
+  play_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnimationTimeline */, "play", []);
+
+  play_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AnimationTimeline */, "play", [__arg_0]);
+}
+
+class BlinkAppBannerPromptResult {
+  static final instance = new BlinkAppBannerPromptResult();
+
+  outcome_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AppBannerPromptResult */, "outcome");
+
+  platform_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AppBannerPromptResult */, "platform");
+}
+
+class BlinkApplicationCache extends BlinkEventTarget {
+  static final instance = new BlinkApplicationCache();
+
+  oncached_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "oncached");
+
+  oncached_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "oncached", __arg_0);
+
+  onchecking_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onchecking");
+
+  onchecking_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "onchecking", __arg_0);
+
+  ondownloading_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "ondownloading");
+
+  ondownloading_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* ApplicationCache */, "ondownloading", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "onerror", __arg_0);
+
+  onnoupdate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onnoupdate");
+
+  onnoupdate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "onnoupdate", __arg_0);
+
+  onobsolete_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onobsolete");
+
+  onobsolete_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "onobsolete", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ApplicationCache */, "onprogress", __arg_0);
+
+  onupdateready_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "onupdateready");
+
+  onupdateready_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* ApplicationCache */, "onupdateready", __arg_0);
+
+  status_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCache */, "status");
+
+  abort_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ApplicationCache */, "abort", []);
+
+  swapCache_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ApplicationCache */, "swapCache", []);
+
+  update_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ApplicationCache */, "update", []);
+}
+
+class BlinkApplicationCacheErrorEvent extends BlinkEvent {
+  static final instance = new BlinkApplicationCacheErrorEvent();
+
+  constructorCallback_0_() => Blink_JsNative_DomException
+      .callConstructor0("ApplicationCacheErrorEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("ApplicationCacheErrorEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("ApplicationCacheErrorEvent", [__arg_0, __arg_1]);
+
+  message_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCacheErrorEvent */, "message");
+
+  reason_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCacheErrorEvent */, "reason");
+
+  status_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCacheErrorEvent */, "status");
+
+  url_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ApplicationCacheErrorEvent */, "url");
+}
+
+class BlinkArrayBuffer {
+  static final instance = new BlinkArrayBuffer();
+
+  byteLength_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ArrayBuffer */, "byteLength");
+}
+
+class BlinkArrayBufferView {
+  static final instance = new BlinkArrayBufferView();
+
+  buffer_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ArrayBufferView */, "buffer");
+
+  byteLength_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ArrayBufferView */, "byteLength");
+
+  byteOffset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ArrayBufferView */, "byteOffset");
+}
+
+class BlinkAttr extends BlinkNode {
+  static final instance = new BlinkAttr();
+
+  localName_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "localName");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "name");
+
+  namespaceURI_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "namespaceURI");
+
+  nodeValue_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "nodeValue");
+
+  nodeValue_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Attr */, "nodeValue", __arg_0);
+
+  ownerElement_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "ownerElement");
+
+  prefix_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "prefix");
+
+  specified_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "specified");
+
+  textContent_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "textContent");
+
+  textContent_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Attr */, "textContent", __arg_0);
+
+  value_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Attr */, "value");
+
+  value_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Attr */, "value", __arg_0);
+}
+
+class BlinkAudioBuffer {
+  static final instance = new BlinkAudioBuffer();
+
+  duration_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBuffer */, "duration");
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBuffer */, "length");
+
+  numberOfChannels_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBuffer */, "numberOfChannels");
+
+  sampleRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBuffer */, "sampleRate");
+
+  copyFromChannel_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "copyFromChannel", []);
+
+  copyFromChannel_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "copyFromChannel", [__arg_0]);
+
+  copyFromChannel_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioBuffer */, "copyFromChannel", [__arg_0, __arg_1]);
+
+  copyFromChannel_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioBuffer */,
+          "copyFromChannel", [__arg_0, __arg_1, __arg_2]);
+
+  copyToChannel_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "copyToChannel", []);
+
+  copyToChannel_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "copyToChannel", [__arg_0]);
+
+  copyToChannel_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioBuffer */, "copyToChannel", [__arg_0, __arg_1]);
+
+  copyToChannel_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioBuffer */,
+          "copyToChannel", [__arg_0, __arg_1, __arg_2]);
+
+  getChannelData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "getChannelData", []);
+
+  getChannelData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBuffer */, "getChannelData", [__arg_0]);
+}
+
+class BlinkAudioBufferCallback {
+  static final instance = new BlinkAudioBufferCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkAudioBufferSourceNode extends BlinkAudioSourceNode {
+  static final instance = new BlinkAudioBufferSourceNode();
+
+  buffer_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "buffer");
+
+  buffer_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioBufferSourceNode */, "buffer", __arg_0);
+
+  detune_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "detune");
+
+  loop_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "loop");
+
+  loop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioBufferSourceNode */, "loop", __arg_0);
+
+  loopEnd_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "loopEnd");
+
+  loopEnd_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioBufferSourceNode */, "loopEnd", __arg_0);
+
+  loopStart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "loopStart");
+
+  loopStart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioBufferSourceNode */, "loopStart", __arg_0);
+
+  onended_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "onended");
+
+  onended_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioBufferSourceNode */, "onended", __arg_0);
+
+  playbackRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioBufferSourceNode */, "playbackRate");
+
+  start_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferSourceNode */, "start", []);
+
+  start_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferSourceNode */, "start", [__arg_0]);
+
+  start_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioBufferSourceNode */, "start", [__arg_0, __arg_1]);
+
+  start_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioBufferSourceNode */,
+          "start", [__arg_0, __arg_1, __arg_2]);
+
+  stop_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferSourceNode */, "stop", []);
+
+  stop_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioBufferSourceNode */, "stop", [__arg_0]);
+}
+
+class BlinkAudioContext extends BlinkEventTarget {
+  static final instance = new BlinkAudioContext();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("AudioContext");
+
+  currentTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "currentTime");
+
+  destination_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "destination");
+
+  listener_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "listener");
+
+  onstatechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "onstatechange");
+
+  onstatechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioContext */, "onstatechange", __arg_0);
+
+  sampleRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "sampleRate");
+
+  state_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioContext */, "state");
+
+  close_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "close", []);
+
+  createAnalyser_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createAnalyser", []);
+
+  createBiquadFilter_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createBiquadFilter", []);
+
+  createBuffer_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createBuffer", [__arg_0]);
+
+  createBuffer_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createBuffer", [__arg_0, __arg_1]);
+
+  createBuffer_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioContext */,
+          "createBuffer", [__arg_0, __arg_1, __arg_2]);
+
+  createBufferSource_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createBufferSource", []);
+
+  createChannelMerger_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createChannelMerger", []);
+
+  createChannelMerger_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createChannelMerger", [__arg_0]);
+
+  createChannelSplitter_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createChannelSplitter", []);
+
+  createChannelSplitter_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createChannelSplitter", [__arg_0]);
+
+  createConvolver_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createConvolver", []);
+
+  createDelay_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createDelay", []);
+
+  createDelay_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createDelay", [__arg_0]);
+
+  createDynamicsCompressor_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createDynamicsCompressor", []);
+
+  createGain_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createGain", []);
+
+  createMediaElementSource_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createMediaElementSource", []);
+
+  createMediaElementSource_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createMediaElementSource", [__arg_0]);
+
+  createMediaStreamDestination_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createMediaStreamDestination", []);
+
+  createMediaStreamSource_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createMediaStreamSource", []);
+
+  createMediaStreamSource_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createMediaStreamSource", [__arg_0]);
+
+  createOscillator_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createOscillator", []);
+
+  createPanner_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createPanner", []);
+
+  createPeriodicWave_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createPeriodicWave", []);
+
+  createPeriodicWave_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createPeriodicWave", [__arg_0]);
+
+  createPeriodicWave_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createPeriodicWave", [__arg_0, __arg_1]);
+
+  createScriptProcessor_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createScriptProcessor", []);
+
+  createScriptProcessor_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "createScriptProcessor", [__arg_0]);
+
+  createScriptProcessor_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioContext */,
+          "createScriptProcessor", [__arg_0, __arg_1]);
+
+  createScriptProcessor_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioContext */,
+          "createScriptProcessor", [__arg_0, __arg_1, __arg_2]);
+
+  createStereoPanner_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createStereoPanner", []);
+
+  createWaveShaper_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "createWaveShaper", []);
+
+  decodeAudioData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "decodeAudioData", []);
+
+  decodeAudioData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "decodeAudioData", [__arg_0]);
+
+  decodeAudioData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioContext */, "decodeAudioData", [__arg_0, __arg_1]);
+
+  decodeAudioData_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioContext */,
+          "decodeAudioData", [__arg_0, __arg_1, __arg_2]);
+
+  resume_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "resume", []);
+
+  suspend_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioContext */, "suspend", []);
+}
+
+class BlinkAudioDestinationNode extends BlinkAudioNode {
+  static final instance = new BlinkAudioDestinationNode();
+
+  maxChannelCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioDestinationNode */, "maxChannelCount");
+}
+
+class BlinkAudioListener {
+  static final instance = new BlinkAudioListener();
+
+  dopplerFactor_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioListener */, "dopplerFactor");
+
+  dopplerFactor_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioListener */, "dopplerFactor", __arg_0);
+
+  speedOfSound_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioListener */, "speedOfSound");
+
+  speedOfSound_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioListener */, "speedOfSound", __arg_0);
+
+  setOrientation_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioListener */,
+          "setOrientation", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  setOrientation_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioListener */,
+          "setOrientation", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  setOrientation_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioListener */,
+          "setOrientation",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  setPosition_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioListener */, "setPosition", [__arg_0]);
+
+  setPosition_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioListener */, "setPosition", [__arg_0, __arg_1]);
+
+  setPosition_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioListener */,
+          "setPosition", [__arg_0, __arg_1, __arg_2]);
+
+  setVelocity_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioListener */, "setVelocity", [__arg_0]);
+
+  setVelocity_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioListener */, "setVelocity", [__arg_0, __arg_1]);
+
+  setVelocity_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioListener */,
+          "setVelocity", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkAudioNode extends BlinkEventTarget {
+  static final instance = new BlinkAudioNode();
+
+  channelCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioNode */, "channelCount");
+
+  channelCount_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioNode */, "channelCount", __arg_0);
+
+  channelCountMode_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioNode */, "channelCountMode");
+
+  channelCountMode_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioNode */, "channelCountMode", __arg_0);
+
+  channelInterpretation_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* AudioNode */, "channelInterpretation");
+
+  channelInterpretation_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioNode */, "channelInterpretation", __arg_0);
+
+  context_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* AudioNode */, "context");
+
+  numberOfInputs_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioNode */, "numberOfInputs");
+
+  numberOfOutputs_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioNode */, "numberOfOutputs");
+
+  connect_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "connect", []);
+
+  connect_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "connect", [__arg_0]);
+
+  connect_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "connect", [__arg_0, __arg_1]);
+
+  connect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioNode */, "connect", [__arg_0, __arg_1, __arg_2]);
+
+  disconnect_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "disconnect", []);
+
+  disconnect_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "disconnect", [__arg_0]);
+
+  disconnect_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioNode */, "disconnect", [__arg_0, __arg_1]);
+
+  disconnect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioNode */, "disconnect", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkAudioParam {
+  static final instance = new BlinkAudioParam();
+
+  defaultValue_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioParam */, "defaultValue");
+
+  value_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* AudioParam */, "value");
+
+  value_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioParam */, "value", __arg_0);
+
+  cancelScheduledValues_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "cancelScheduledValues", []);
+
+  cancelScheduledValues_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "cancelScheduledValues", [__arg_0]);
+
+  exponentialRampToValueAtTime_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "exponentialRampToValueAtTime", []);
+
+  exponentialRampToValueAtTime_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "exponentialRampToValueAtTime", [__arg_0]);
+
+  exponentialRampToValueAtTime_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioParam */,
+          "exponentialRampToValueAtTime", [__arg_0, __arg_1]);
+
+  linearRampToValueAtTime_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "linearRampToValueAtTime", []);
+
+  linearRampToValueAtTime_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "linearRampToValueAtTime", [__arg_0]);
+
+  linearRampToValueAtTime_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioParam */,
+          "linearRampToValueAtTime", [__arg_0, __arg_1]);
+
+  setTargetAtTime_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "setTargetAtTime", [__arg_0]);
+
+  setTargetAtTime_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "setTargetAtTime", [__arg_0, __arg_1]);
+
+  setTargetAtTime_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioParam */,
+          "setTargetAtTime", [__arg_0, __arg_1, __arg_2]);
+
+  setValueAtTime_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "setValueAtTime", []);
+
+  setValueAtTime_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "setValueAtTime", [__arg_0]);
+
+  setValueAtTime_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "setValueAtTime", [__arg_0, __arg_1]);
+
+  setValueCurveAtTime_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioParam */, "setValueCurveAtTime", [__arg_0]);
+
+  setValueCurveAtTime_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* AudioParam */, "setValueCurveAtTime", [__arg_0, __arg_1]);
+
+  setValueCurveAtTime_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* AudioParam */,
+          "setValueCurveAtTime", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkAudioProcessingEvent extends BlinkEvent {
+  static final instance = new BlinkAudioProcessingEvent();
+
+  inputBuffer_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioProcessingEvent */, "inputBuffer");
+
+  outputBuffer_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioProcessingEvent */, "outputBuffer");
+
+  playbackTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioProcessingEvent */, "playbackTime");
+}
+
+class BlinkAudioSourceNode extends BlinkAudioNode {
+  static final instance = new BlinkAudioSourceNode();
+}
+
+class BlinkAudioTrack {
+  static final instance = new BlinkAudioTrack();
+
+  enabled_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrack */, "enabled");
+
+  enabled_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioTrack */, "enabled", __arg_0);
+
+  id_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* AudioTrack */, "id");
+
+  kind_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* AudioTrack */, "kind");
+
+  label_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* AudioTrack */, "label");
+
+  language_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrack */, "language");
+}
+
+class BlinkAudioTrackList extends BlinkEventTarget {
+  static final instance = new BlinkAudioTrackList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrackList */, "length");
+
+  onaddtrack_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrackList */, "onaddtrack");
+
+  onaddtrack_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioTrackList */, "onaddtrack", __arg_0);
+
+  onchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrackList */, "onchange");
+
+  onchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AudioTrackList */, "onchange", __arg_0);
+
+  onremovetrack_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AudioTrackList */, "onremovetrack");
+
+  onremovetrack_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* AudioTrackList */, "onremovetrack", __arg_0);
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioTrackList */, "__getter__", [__arg_0]);
+
+  getTrackById_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioTrackList */, "getTrackById", []);
+
+  getTrackById_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* AudioTrackList */, "getTrackById", [__arg_0]);
+}
+
+class BlinkAutocompleteErrorEvent extends BlinkEvent {
+  static final instance = new BlinkAutocompleteErrorEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("AutocompleteErrorEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("AutocompleteErrorEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("AutocompleteErrorEvent", [__arg_0, __arg_1]);
+
+  reason_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AutocompleteErrorEvent */, "reason");
+}
+
+class BlinkBarProp {
+  static final instance = new BlinkBarProp();
+
+  visible_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* BarProp */, "visible");
+}
+
+class BlinkBatteryManager extends BlinkEventTarget {
+  static final instance = new BlinkBatteryManager();
+
+  charging_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "charging");
+
+  chargingTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "chargingTime");
+
+  dischargingTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "dischargingTime");
+
+  level_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "level");
+
+  onchargingchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "onchargingchange");
+
+  onchargingchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* BatteryManager */, "onchargingchange", __arg_0);
+
+  onchargingtimechange_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* BatteryManager */, "onchargingtimechange");
+
+  onchargingtimechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* BatteryManager */, "onchargingtimechange", __arg_0);
+
+  ondischargingtimechange_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* BatteryManager */, "ondischargingtimechange");
+
+  ondischargingtimechange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* BatteryManager */, "ondischargingtimechange", __arg_0);
+
+  onlevelchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BatteryManager */, "onlevelchange");
+
+  onlevelchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* BatteryManager */, "onlevelchange", __arg_0);
+}
+
+class BlinkBeforeInstallPromptEvent extends BlinkEvent {
+  static final instance = new BlinkBeforeInstallPromptEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("BeforeInstallPromptEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("BeforeInstallPromptEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("BeforeInstallPromptEvent", [__arg_0, __arg_1]);
+
+  platforms_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BeforeInstallPromptEvent */, "platforms");
+
+  userChoice_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BeforeInstallPromptEvent */, "userChoice");
+
+  prompt_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* BeforeInstallPromptEvent */, "prompt", []);
+}
+
+class BlinkBeforeUnloadEvent extends BlinkEvent {
+  static final instance = new BlinkBeforeUnloadEvent();
+
+  returnValue_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BeforeUnloadEvent */, "returnValue");
+
+  returnValue_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* BeforeUnloadEvent */, "returnValue", __arg_0);
+}
+
+class BlinkBiquadFilterNode extends BlinkAudioNode {
+  static final instance = new BlinkBiquadFilterNode();
+
+  Q_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BiquadFilterNode */, "Q");
+
+  detune_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BiquadFilterNode */, "detune");
+
+  frequency_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BiquadFilterNode */, "frequency");
+
+  gain_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BiquadFilterNode */, "gain");
+
+  type_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BiquadFilterNode */, "type");
+
+  type_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* BiquadFilterNode */, "type", __arg_0);
+
+  getFrequencyResponse_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* BiquadFilterNode */, "getFrequencyResponse", [__arg_0]);
+
+  getFrequencyResponse_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* BiquadFilterNode */,
+          "getFrequencyResponse", [__arg_0, __arg_1]);
+
+  getFrequencyResponse_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* BiquadFilterNode */,
+          "getFrequencyResponse", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkBlob {
+  static final instance = new BlinkBlob();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("Blob");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("Blob", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callConstructor("Blob", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("Blob", [__arg_0, __arg_1, __arg_2]);
+
+  size_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Blob */, "size");
+
+  type_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Blob */, "type");
+
+  close_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Blob */, "close", []);
+
+  slice_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Blob */, "slice", []);
+
+  slice_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Blob */, "slice", [__arg_0]);
+
+  slice_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Blob */, "slice", [__arg_0, __arg_1]);
+
+  slice_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Blob */, "slice", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkBluetooth {
+  static final instance = new BlinkBluetooth();
+
+  requestDevice_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Bluetooth */, "requestDevice", []);
+
+  requestDevice_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Bluetooth */, "requestDevice", [__arg_0]);
+}
+
+class BlinkBluetoothDevice {
+  static final instance = new BlinkBluetoothDevice();
+
+  deviceClass_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "deviceClass");
+
+  instanceID_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "instanceID");
+
+  name_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "name");
+
+  paired_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "paired");
+
+  productID_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "productID");
+
+  productVersion_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "productVersion");
+
+  vendorID_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "vendorID");
+
+  vendorIDSource_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothDevice */, "vendorIDSource");
+
+  connectGATT_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* BluetoothDevice */, "connectGATT", []);
+}
+
+class BlinkBluetoothGATTCharacteristic {
+  static final instance = new BlinkBluetoothGATTCharacteristic();
+
+  uuid_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothGATTCharacteristic */, "uuid");
+
+  readValue_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* BluetoothGATTCharacteristic */, "readValue", []);
+
+  writeValue_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* BluetoothGATTCharacteristic */, "writeValue", []);
+
+  writeValue_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* BluetoothGATTCharacteristic */, "writeValue", [__arg_0]);
+}
+
+class BlinkBluetoothGATTRemoteServer {
+  static final instance = new BlinkBluetoothGATTRemoteServer();
+
+  connected_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothGATTRemoteServer */, "connected");
+
+  getPrimaryService_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* BluetoothGATTRemoteServer */, "getPrimaryService", []);
+
+  getPrimaryService_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* BluetoothGATTRemoteServer */,
+          "getPrimaryService",
+          [__arg_0]);
+}
+
+class BlinkBluetoothGATTService {
+  static final instance = new BlinkBluetoothGATTService();
+
+  isPrimary_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothGATTService */, "isPrimary");
+
+  uuid_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* BluetoothGATTService */, "uuid");
+
+  getCharacteristic_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* BluetoothGATTService */, "getCharacteristic", []);
+
+  getCharacteristic_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* BluetoothGATTService */, "getCharacteristic", [__arg_0]);
+}
+
+class BlinkBluetoothUUID {
+  static final instance = new BlinkBluetoothUUID();
+
+  canonicalUUID_Callback_0_() => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "canonicalUUID",
+      []);
+
+  canonicalUUID_Callback_1_(__arg_0) => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "canonicalUUID",
+      [__arg_0]);
+
+  getCharacteristic_Callback_0_() => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "getCharacteristic",
+      []);
+
+  getCharacteristic_Callback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          Blink_JsNative_DomException.getProperty(
+              js.context, "BluetoothUUID") /* BluetoothUUID */,
+          "getCharacteristic",
+          [__arg_0]);
+
+  getDescriptor_Callback_0_() => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "getDescriptor",
+      []);
+
+  getDescriptor_Callback_1_(__arg_0) => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "getDescriptor",
+      [__arg_0]);
+
+  getService_Callback_0_() => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "getService",
+      []);
+
+  getService_Callback_1_(__arg_0) => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(
+          js.context, "BluetoothUUID") /* BluetoothUUID */,
+      "getService",
+      [__arg_0]);
+}
+
+class BlinkBody {
+  static final instance = new BlinkBody();
+
+  bodyUsed_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Body */, "bodyUsed");
+
+  arrayBuffer_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Body */, "arrayBuffer", []);
+
+  blob_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Body */, "blob", []);
+
+  json_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Body */, "json", []);
+
+  text_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Body */, "text", []);
+}
+
+class BlinkCDATASection extends BlinkText {
+  static final instance = new BlinkCDATASection();
+}
+
+class BlinkCHROMIUMSubscribeUniform {
+  static final instance = new BlinkCHROMIUMSubscribeUniform();
+
+  bindValuebufferCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */, "bindValuebufferCHROMIUM", []);
+
+  bindValuebufferCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "bindValuebufferCHROMIUM",
+          [__arg_0]);
+
+  bindValuebufferCHROMIUM_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "bindValuebufferCHROMIUM",
+          [__arg_0, __arg_1]);
+
+  createValuebufferCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "createValuebufferCHROMIUM", []);
+
+  deleteValuebufferCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "deleteValuebufferCHROMIUM", []);
+
+  deleteValuebufferCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "deleteValuebufferCHROMIUM",
+          [__arg_0]);
+
+  isValuebufferCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */, "isValuebufferCHROMIUM", []);
+
+  isValuebufferCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "isValuebufferCHROMIUM",
+          [__arg_0]);
+
+  populateSubscribedValuesCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "populateSubscribedValuesCHROMIUM", []);
+
+  populateSubscribedValuesCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "populateSubscribedValuesCHROMIUM",
+          [__arg_0]);
+
+  subscribeValueCHROMIUM_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */, "subscribeValueCHROMIUM", []);
+
+  subscribeValueCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "subscribeValueCHROMIUM",
+          [__arg_0]);
+
+  subscribeValueCHROMIUM_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "subscribeValueCHROMIUM",
+          [__arg_0, __arg_1]);
+
+  uniformValuebufferCHROMIUM_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "uniformValuebufferCHROMIUM",
+          [__arg_0]);
+
+  uniformValuebufferCHROMIUM_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "uniformValuebufferCHROMIUM",
+          [__arg_0, __arg_1]);
+
+  uniformValuebufferCHROMIUM_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CHROMIUMSubscribeUniform */,
+          "uniformValuebufferCHROMIUM",
+          [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkCHROMIUMValuebuffer {
+  static final instance = new BlinkCHROMIUMValuebuffer();
+}
+
+class BlinkCSS {
+  static final instance = new BlinkCSS();
+
+  supports_Callback_0_() => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(js.context, "CSS") /* CSS */,
+      "supports", []);
+
+  supports_Callback_1_(__arg_0) => Blink_JsNative_DomException.callMethod(
+      Blink_JsNative_DomException.getProperty(js.context, "CSS") /* CSS */,
+      "supports",
+      [__arg_0]);
+
+  supports_Callback_2_(__arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          Blink_JsNative_DomException.getProperty(js.context, "CSS") /* CSS */,
+          "supports",
+          [__arg_0, __arg_1]);
+}
+
+class BlinkCSSCharsetRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSCharsetRule();
+
+  encoding_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSCharsetRule */, "encoding");
+
+  encoding_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CSSCharsetRule */, "encoding", __arg_0);
+}
+
+class BlinkCSSFontFaceRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSFontFaceRule();
+
+  style_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSFontFaceRule */, "style");
+}
+
+class BlinkCSSGroupingRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSGroupingRule();
+
+  cssRules_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSGroupingRule */, "cssRules");
+
+  deleteRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSGroupingRule */, "deleteRule", []);
+
+  deleteRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSGroupingRule */, "deleteRule", [__arg_0]);
+
+  insertRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSGroupingRule */, "insertRule", []);
+
+  insertRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSGroupingRule */, "insertRule", [__arg_0]);
+
+  insertRule_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CSSGroupingRule */, "insertRule", [__arg_0, __arg_1]);
+}
+
+class BlinkCSSImportRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSImportRule();
+
+  href_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSImportRule */, "href");
+
+  media_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSImportRule */, "media");
+
+  styleSheet_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSImportRule */, "styleSheet");
+}
+
+class BlinkCSSKeyframeRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSKeyframeRule();
+
+  keyText_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSKeyframeRule */, "keyText");
+
+  keyText_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CSSKeyframeRule */, "keyText", __arg_0);
+
+  style_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSKeyframeRule */, "style");
+}
+
+class BlinkCSSKeyframesRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSKeyframesRule();
+
+  cssRules_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSKeyframesRule */, "cssRules");
+
+  name_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSKeyframesRule */, "name");
+
+  name_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CSSKeyframesRule */, "name", __arg_0);
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "__getter__", [__arg_0]);
+
+  appendRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "appendRule", []);
+
+  appendRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "appendRule", [__arg_0]);
+
+  deleteRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "deleteRule", []);
+
+  deleteRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "deleteRule", [__arg_0]);
+
+  findRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "findRule", []);
+
+  findRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSKeyframesRule */, "findRule", [__arg_0]);
+}
+
+class BlinkCSSMediaRule extends BlinkCSSGroupingRule {
+  static final instance = new BlinkCSSMediaRule();
+
+  media_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSMediaRule */, "media");
+}
+
+class BlinkCSSPageRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSPageRule();
+
+  selectorText_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSPageRule */, "selectorText");
+
+  selectorText_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* CSSPageRule */, "selectorText", __arg_0);
+
+  style_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CSSPageRule */, "style");
+}
+
+class BlinkCSSRule {
+  static final instance = new BlinkCSSRule();
+
+  cssText_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CSSRule */, "cssText");
+
+  cssText_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CSSRule */, "cssText", __arg_0);
+
+  parentRule_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSRule */, "parentRule");
+
+  parentStyleSheet_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSRule */, "parentStyleSheet");
+
+  type_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CSSRule */, "type");
+}
+
+class BlinkCSSRuleList {
+  static final instance = new BlinkCSSRuleList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSRuleList */, "length");
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSRuleList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSRuleList */, "item", [__arg_0]);
+}
+
+class BlinkCSSStyleDeclaration {
+  static final instance = new BlinkCSSStyleDeclaration();
+
+  cssText_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleDeclaration */, "cssText");
+
+  cssText_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CSSStyleDeclaration */, "cssText", __arg_0);
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleDeclaration */, "length");
+
+  parentRule_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleDeclaration */, "parentRule");
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "__getter__", [__arg_0]);
+
+  $__propertyQuery___Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_PQ_CSSStyleDeclaration";
+
+  $__setter___Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CSSStyleDeclaration */, "__setter__", [__arg_0, __arg_1]);
+
+  getPropertyPriority_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "getPropertyPriority", []);
+
+  getPropertyPriority_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CSSStyleDeclaration */, "getPropertyPriority", [__arg_0]);
+
+  getPropertyValue_Callback_0_(mthis)
+      native "Blink_Operation_0_CSSStyleDeclaration_getPropertyValue";
+
+  getPropertyValue_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_CSSStyleDeclaration_getPropertyValue"; /* __arg_0 */
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "item", [__arg_0]);
+
+  removeProperty_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "removeProperty", []);
+
+  removeProperty_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleDeclaration */, "removeProperty", [__arg_0]);
+
+  setProperty_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_CSSStyleDeclaration_setProperty"; /* __arg_0 */
+
+  setProperty_Callback_2_(mthis, __arg_0, __arg_1)
+      native "Blink_Operation_CSSStyleDeclaration_setProperty"; /* __arg_0, __arg_1 */
+
+  setProperty_Callback_3_(mthis, __arg_0, __arg_1, __arg_2)
+      native "Blink_Operation_CSSStyleDeclaration_setProperty"; /* __arg_0, __arg_1, __arg_2 */
+
+}
+
+class BlinkCSSStyleRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSStyleRule();
+
+  selectorText_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleRule */, "selectorText");
+
+  selectorText_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* CSSStyleRule */, "selectorText", __arg_0);
+
+  style_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleRule */, "style");
+}
+
+class BlinkCSSStyleSheet extends BlinkStyleSheet {
+  static final instance = new BlinkCSSStyleSheet();
+
+  cssRules_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleSheet */, "cssRules");
+
+  ownerRule_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleSheet */, "ownerRule");
+
+  rules_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSStyleSheet */, "rules");
+
+  addRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "addRule", []);
+
+  addRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "addRule", [__arg_0]);
+
+  addRule_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "addRule", [__arg_0, __arg_1]);
+
+  addRule_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CSSStyleSheet */, "addRule", [__arg_0, __arg_1, __arg_2]);
+
+  deleteRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "deleteRule", []);
+
+  deleteRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "deleteRule", [__arg_0]);
+
+  insertRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "insertRule", []);
+
+  insertRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "insertRule", [__arg_0]);
+
+  insertRule_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "insertRule", [__arg_0, __arg_1]);
+
+  removeRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "removeRule", []);
+
+  removeRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSStyleSheet */, "removeRule", [__arg_0]);
+}
+
+class BlinkCSSSupportsRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSSupportsRule();
+
+  conditionText_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSSupportsRule */, "conditionText");
+
+  cssRules_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSSupportsRule */, "cssRules");
+
+  deleteRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSSupportsRule */, "deleteRule", []);
+
+  deleteRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSSupportsRule */, "deleteRule", [__arg_0]);
+
+  insertRule_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSSupportsRule */, "insertRule", []);
+
+  insertRule_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CSSSupportsRule */, "insertRule", [__arg_0]);
+
+  insertRule_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CSSSupportsRule */, "insertRule", [__arg_0, __arg_1]);
+}
+
+class BlinkCSSViewportRule extends BlinkCSSRule {
+  static final instance = new BlinkCSSViewportRule();
+
+  style_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CSSViewportRule */, "style");
+}
+
+class BlinkCache {
+  static final instance = new BlinkCache();
+
+  add_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "add", []);
+
+  add_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "add", [__arg_0]);
+
+  addAll_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "addAll", []);
+
+  addAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "addAll", [__arg_0]);
+
+  delete_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "delete", []);
+
+  delete_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "delete", [__arg_0]);
+
+  delete_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "delete", [__arg_0, __arg_1]);
+
+  keys_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "keys", []);
+
+  keys_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "keys", [__arg_0]);
+
+  keys_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "keys", [__arg_0, __arg_1]);
+
+  match_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "match", []);
+
+  match_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "match", [__arg_0]);
+
+  match_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "match", [__arg_0, __arg_1]);
+
+  put_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Cache */, "put", []);
+
+  put_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "put", [__arg_0]);
+
+  put_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Cache */, "put", [__arg_0, __arg_1]);
+}
+
+class BlinkCacheStorage {
+  static final instance = new BlinkCacheStorage();
+
+  delete_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "delete", []);
+
+  delete_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "delete", [__arg_0]);
+
+  has_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "has", []);
+
+  has_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "has", [__arg_0]);
+
+  keys_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "keys", []);
+
+  match_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "match", []);
+
+  match_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "match", [__arg_0]);
+
+  match_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "match", [__arg_0, __arg_1]);
+
+  open_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "open", []);
+
+  open_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CacheStorage */, "open", [__arg_0]);
+}
+
+class BlinkCanvasGradient {
+  static final instance = new BlinkCanvasGradient();
+
+  addColorStop_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasGradient */, "addColorStop", []);
+
+  addColorStop_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasGradient */, "addColorStop", [__arg_0]);
+
+  addColorStop_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasGradient */, "addColorStop", [__arg_0, __arg_1]);
+}
+
+class BlinkCanvasPathMethods {
+  static final instance = new BlinkCanvasPathMethods();
+
+  arc_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  arc_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  arc_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  arcTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "arcTo", [__arg_0, __arg_1, __arg_2]);
+
+  arcTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arcTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  arcTo_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arcTo", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  bezierCurveTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "bezierCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  bezierCurveTo_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "bezierCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  bezierCurveTo_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */,
+          "bezierCurveTo",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  closePath_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "closePath", []);
+
+  ellipse_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "ellipse", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  ellipse_Callback_7_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */,
+          "ellipse",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+
+  ellipse_Callback_8_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "ellipse", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7
+      ]);
+
+  lineTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", []);
+
+  lineTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", [__arg_0]);
+
+  lineTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", [__arg_0, __arg_1]);
+
+  moveTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", []);
+
+  moveTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", [__arg_0]);
+
+  moveTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", [__arg_0, __arg_1]);
+
+  quadraticCurveTo_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1]);
+
+  quadraticCurveTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1, __arg_2]);
+
+  quadraticCurveTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  rect_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "rect", [__arg_0, __arg_1]);
+
+  rect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "rect", [__arg_0, __arg_1, __arg_2]);
+
+  rect_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "rect", [__arg_0, __arg_1, __arg_2, __arg_3]);
+}
+
+class BlinkCanvasPattern {
+  static final instance = new BlinkCanvasPattern();
+
+  setTransform_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPattern */, "setTransform", []);
+
+  setTransform_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPattern */, "setTransform", [__arg_0]);
+}
+
+class BlinkCanvasRenderingContext2D {
+  static final instance = new BlinkCanvasRenderingContext2D();
+
+  canvas_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "canvas");
+
+  currentTransform_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "currentTransform");
+
+  currentTransform_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "currentTransform", __arg_0);
+
+  direction_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "direction");
+
+  direction_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "direction", __arg_0);
+
+  fillStyle_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "fillStyle");
+
+  fillStyle_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "fillStyle", __arg_0);
+
+  filter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "filter");
+
+  filter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "filter", __arg_0);
+
+  font_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "font");
+
+  font_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "font", __arg_0);
+
+  globalAlpha_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "globalAlpha");
+
+  globalAlpha_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "globalAlpha", __arg_0);
+
+  globalCompositeOperation_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* CanvasRenderingContext2D */, "globalCompositeOperation");
+
+  globalCompositeOperation_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */,
+          "globalCompositeOperation",
+          __arg_0);
+
+  imageSmoothingEnabled_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* CanvasRenderingContext2D */, "imageSmoothingEnabled");
+
+  imageSmoothingEnabled_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */,
+          "imageSmoothingEnabled",
+          __arg_0);
+
+  lineCap_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "lineCap");
+
+  lineCap_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "lineCap", __arg_0);
+
+  lineDashOffset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "lineDashOffset");
+
+  lineDashOffset_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "lineDashOffset", __arg_0);
+
+  lineJoin_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "lineJoin");
+
+  lineJoin_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "lineJoin", __arg_0);
+
+  lineWidth_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "lineWidth");
+
+  lineWidth_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "lineWidth", __arg_0);
+
+  miterLimit_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "miterLimit");
+
+  miterLimit_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "miterLimit", __arg_0);
+
+  shadowBlur_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "shadowBlur");
+
+  shadowBlur_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "shadowBlur", __arg_0);
+
+  shadowColor_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "shadowColor");
+
+  shadowColor_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "shadowColor", __arg_0);
+
+  shadowOffsetX_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "shadowOffsetX");
+
+  shadowOffsetX_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "shadowOffsetX", __arg_0);
+
+  shadowOffsetY_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "shadowOffsetY");
+
+  shadowOffsetY_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "shadowOffsetY", __arg_0);
+
+  strokeStyle_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "strokeStyle");
+
+  strokeStyle_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "strokeStyle", __arg_0);
+
+  textAlign_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "textAlign");
+
+  textAlign_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CanvasRenderingContext2D */, "textAlign", __arg_0);
+
+  textBaseline_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CanvasRenderingContext2D */, "textBaseline");
+
+  textBaseline_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */, "textBaseline", __arg_0);
+
+  webkitImageSmoothingEnabled_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* CanvasRenderingContext2D */, "webkitImageSmoothingEnabled");
+
+  webkitImageSmoothingEnabled_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* CanvasRenderingContext2D */,
+          "webkitImageSmoothingEnabled",
+          __arg_0);
+
+  addHitRegion_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "addHitRegion", []);
+
+  addHitRegion_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "addHitRegion", [__arg_0]);
+
+  beginPath_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "beginPath", []);
+
+  clearHitRegions_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "clearHitRegions", []);
+
+  clearRect_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "clearRect",
+          [__arg_0, __arg_1]);
+
+  clearRect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "clearRect",
+          [__arg_0, __arg_1, __arg_2]);
+
+  clearRect_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "clearRect",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  clip_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "clip", []);
+
+  clip_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "clip", [__arg_0]);
+
+  clip_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "clip", [__arg_0, __arg_1]);
+
+  createImageData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "createImageData", []);
+
+  createImageData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "createImageData", [__arg_0]);
+
+  createImageData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createImageData",
+          [__arg_0, __arg_1]);
+
+  createLinearGradient_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createLinearGradient",
+          [__arg_0, __arg_1]);
+
+  createLinearGradient_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createLinearGradient",
+          [__arg_0, __arg_1, __arg_2]);
+
+  createLinearGradient_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createLinearGradient",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  createPattern_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "createPattern", []);
+
+  createPattern_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "createPattern", [__arg_0]);
+
+  createPattern_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createPattern",
+          [__arg_0, __arg_1]);
+
+  createRadialGradient_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createRadialGradient",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  createRadialGradient_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createRadialGradient",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  createRadialGradient_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "createRadialGradient",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  drawFocusIfNeeded_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "drawFocusIfNeeded", []);
+
+  drawFocusIfNeeded_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "drawFocusIfNeeded", [__arg_0]);
+
+  drawFocusIfNeeded_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawFocusIfNeeded",
+          [__arg_0, __arg_1]);
+
+  drawImage_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "drawImage", [__arg_0]);
+
+  drawImage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1]);
+
+  drawImage_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1, __arg_2]);
+
+  drawImage_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  drawImage_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  drawImage_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  drawImage_Callback_7_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "drawImage",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+
+  drawImage_Callback_8_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "drawImage", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7
+      ]);
+
+  drawImage_Callback_9_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7, __arg_8) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "drawImage", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7,
+        __arg_8
+      ]);
+
+  fill_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "fill", []);
+
+  fill_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "fill", [__arg_0]);
+
+  fill_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "fill", [__arg_0, __arg_1]);
+
+  fillRect_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "fillRect", [__arg_0, __arg_1]);
+
+  fillRect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "fillRect",
+          [__arg_0, __arg_1, __arg_2]);
+
+  fillRect_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "fillRect",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  fillText_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "fillText", [__arg_0]);
+
+  fillText_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "fillText", [__arg_0, __arg_1]);
+
+  fillText_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "fillText",
+          [__arg_0, __arg_1, __arg_2]);
+
+  fillText_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "fillText",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  getContextAttributes_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "getContextAttributes", []);
+
+  getImageData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "getImageData",
+          [__arg_0, __arg_1]);
+
+  getImageData_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "getImageData",
+          [__arg_0, __arg_1, __arg_2]);
+
+  getImageData_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "getImageData",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  getLineDash_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "getLineDash", []);
+
+  isContextLost_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "isContextLost", []);
+
+  isPointInPath_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "isPointInPath", []);
+
+  isPointInPath_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "isPointInPath", [__arg_0]);
+
+  isPointInPath_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "isPointInPath",
+          [__arg_0, __arg_1]);
+
+  isPointInPath_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "isPointInPath",
+          [__arg_0, __arg_1, __arg_2]);
+
+  isPointInPath_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "isPointInPath",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  isPointInStroke_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "isPointInStroke", []);
+
+  isPointInStroke_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "isPointInStroke", [__arg_0]);
+
+  isPointInStroke_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "isPointInStroke",
+          [__arg_0, __arg_1]);
+
+  isPointInStroke_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "isPointInStroke",
+          [__arg_0, __arg_1, __arg_2]);
+
+  measureText_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "measureText", []);
+
+  measureText_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "measureText", [__arg_0]);
+
+  putImageData_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "putImageData", [__arg_0]);
+
+  putImageData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1]);
+
+  putImageData_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1, __arg_2]);
+
+  putImageData_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  putImageData_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  putImageData_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  putImageData_Callback_7_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "putImageData",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+
+  removeHitRegion_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "removeHitRegion", []);
+
+  removeHitRegion_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "removeHitRegion", [__arg_0]);
+
+  resetTransform_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "resetTransform", []);
+
+  restore_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "restore", []);
+
+  rotate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "rotate", []);
+
+  rotate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "rotate", [__arg_0]);
+
+  save_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "save", []);
+
+  scale_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "scale", []);
+
+  scale_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "scale", [__arg_0]);
+
+  scale_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "scale", [__arg_0, __arg_1]);
+
+  scrollPathIntoView_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "scrollPathIntoView", []);
+
+  scrollPathIntoView_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "scrollPathIntoView",
+          [__arg_0]);
+
+  setLineDash_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "setLineDash", []);
+
+  setLineDash_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "setLineDash", [__arg_0]);
+
+  setTransform_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "setTransform",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  setTransform_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "setTransform",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  setTransform_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "setTransform",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  stroke_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "stroke", []);
+
+  stroke_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "stroke", [__arg_0]);
+
+  strokeRect_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeRect",
+          [__arg_0, __arg_1]);
+
+  strokeRect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeRect",
+          [__arg_0, __arg_1, __arg_2]);
+
+  strokeRect_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeRect",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  strokeText_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */, "strokeText", [__arg_0]);
+
+  strokeText_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeText",
+          [__arg_0, __arg_1]);
+
+  strokeText_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeText",
+          [__arg_0, __arg_1, __arg_2]);
+
+  strokeText_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "strokeText",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  transform_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "transform",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  transform_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "transform",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  transform_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "transform",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  translate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "translate", []);
+
+  translate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasRenderingContext2D */, "translate", [__arg_0]);
+
+  translate_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasRenderingContext2D */,
+          "translate",
+          [__arg_0, __arg_1]);
+
+  arc_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  arc_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  arc_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arc", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  arcTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "arcTo", [__arg_0, __arg_1, __arg_2]);
+
+  arcTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arcTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  arcTo_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "arcTo", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  bezierCurveTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "bezierCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  bezierCurveTo_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "bezierCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  bezierCurveTo_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */,
+          "bezierCurveTo",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  closePath_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "closePath", []);
+
+  ellipse_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "ellipse", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  ellipse_Callback_7_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */,
+          "ellipse",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+
+  ellipse_Callback_8_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "ellipse", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7
+      ]);
+
+  lineTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", []);
+
+  lineTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", [__arg_0]);
+
+  lineTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "lineTo", [__arg_0, __arg_1]);
+
+  moveTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", []);
+
+  moveTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", [__arg_0]);
+
+  moveTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "moveTo", [__arg_0, __arg_1]);
+
+  quadraticCurveTo_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1]);
+
+  quadraticCurveTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1, __arg_2]);
+
+  quadraticCurveTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "quadraticCurveTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  rect_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CanvasPathMethods */, "rect", [__arg_0, __arg_1]);
+
+  rect_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CanvasPathMethods */, "rect", [__arg_0, __arg_1, __arg_2]);
+
+  rect_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CanvasPathMethods */,
+          "rect", [__arg_0, __arg_1, __arg_2, __arg_3]);
+}
+
+class BlinkChannelMergerNode extends BlinkAudioNode {
+  static final instance = new BlinkChannelMergerNode();
+}
+
+class BlinkChannelSplitterNode extends BlinkAudioNode {
+  static final instance = new BlinkChannelSplitterNode();
+}
+
+class BlinkCharacterData extends BlinkNode {
+  static final instance = new BlinkCharacterData();
+
+  data_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CharacterData */, "data");
+
+  data_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CharacterData */, "data", __arg_0);
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CharacterData */, "length");
+
+  appendData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "appendData", []);
+
+  appendData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "appendData", [__arg_0]);
+
+  deleteData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "deleteData", []);
+
+  deleteData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "deleteData", [__arg_0]);
+
+  deleteData_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "deleteData", [__arg_0, __arg_1]);
+
+  insertData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "insertData", []);
+
+  insertData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "insertData", [__arg_0]);
+
+  insertData_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "insertData", [__arg_0, __arg_1]);
+
+  replaceData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "replaceData", [__arg_0]);
+
+  replaceData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CharacterData */, "replaceData", [__arg_0, __arg_1]);
+
+  replaceData_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CharacterData */,
+          "replaceData", [__arg_0, __arg_1, __arg_2]);
+
+  substringData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "substringData", []);
+
+  substringData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CharacterData */, "substringData", [__arg_0]);
+
+  substringData_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CharacterData */, "substringData", [__arg_0, __arg_1]);
+
+  after_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", []);
+
+  after_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", [__arg_0]);
+
+  before_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", []);
+
+  before_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", [__arg_0]);
+
+  remove_Callback_0_(mthis) native "Blink_Operation_0_ChildNode_remove";
+
+  replaceWith_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", []);
+
+  replaceWith_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", [__arg_0]);
+
+  nextElementSibling_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* NonDocumentTypeChildNode */, "nextElementSibling");
+
+  previousElementSibling_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* NonDocumentTypeChildNode */, "previousElementSibling");
+}
+
+class BlinkChildNode {
+  static final instance = new BlinkChildNode();
+
+  after_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", []);
+
+  after_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", [__arg_0]);
+
+  before_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", []);
+
+  before_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", [__arg_0]);
+
+  remove_Callback_0_(mthis) native "Blink_Operation_0_ChildNode_remove";
+
+  replaceWith_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", []);
+
+  replaceWith_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", [__arg_0]);
+}
+
+class BlinkCircularGeofencingRegion extends BlinkGeofencingRegion {
+  static final instance = new BlinkCircularGeofencingRegion();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CircularGeofencingRegion");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("CircularGeofencingRegion", [__arg_0]);
+
+  latitude_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CircularGeofencingRegion */, "latitude");
+
+  longitude_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CircularGeofencingRegion */, "longitude");
+
+  radius_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CircularGeofencingRegion */, "radius");
+}
+
+class BlinkClient {
+  static final instance = new BlinkClient();
+
+  frameType_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Client */, "frameType");
+
+  id_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Client */, "id");
+
+  url_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Client */, "url");
+
+  postMessage_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Client */, "postMessage", []);
+
+  postMessage_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Client */, "postMessage", [__arg_0]);
+
+  postMessage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Client */, "postMessage", [__arg_0, __arg_1]);
+}
+
+class BlinkClientRect {
+  static final instance = new BlinkClientRect();
+
+  bottom_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "bottom");
+
+  height_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "height");
+
+  left_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "left");
+
+  right_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "right");
+
+  top_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "top");
+
+  width_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ClientRect */, "width");
+}
+
+class BlinkClientRectList {
+  static final instance = new BlinkClientRectList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ClientRectList */, "length");
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ClientRectList */, "__getter__", [__arg_0]);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ClientRectList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ClientRectList */, "item", [__arg_0]);
+}
+
+class BlinkClients {
+  static final instance = new BlinkClients();
+
+  claim_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Clients */, "claim", []);
+
+  matchAll_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Clients */, "matchAll", []);
+
+  matchAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Clients */, "matchAll", [__arg_0]);
+
+  openWindow_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Clients */, "openWindow", []);
+
+  openWindow_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Clients */, "openWindow", [__arg_0]);
+}
+
+class BlinkClipboardEvent extends BlinkEvent {
+  static final instance = new BlinkClipboardEvent();
+
+  clipboardData_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ClipboardEvent */, "clipboardData");
+}
+
+class BlinkCloseEvent extends BlinkEvent {
+  static final instance = new BlinkCloseEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CloseEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("CloseEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("CloseEvent", [__arg_0, __arg_1]);
+
+  code_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CloseEvent */, "code");
+
+  reason_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CloseEvent */, "reason");
+
+  wasClean_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CloseEvent */, "wasClean");
+}
+
+class BlinkComment extends BlinkCharacterData {
+  static final instance = new BlinkComment();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("Comment");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("Comment", [__arg_0]);
+}
+
+class BlinkCompositionEvent extends BlinkUIEvent {
+  static final instance = new BlinkCompositionEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CompositionEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("CompositionEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("CompositionEvent", [__arg_0, __arg_1]);
+
+  data_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositionEvent */, "data");
+
+  initCompositionEvent_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CompositionEvent */,
+          "initCompositionEvent", [__arg_0, __arg_1, __arg_2]);
+
+  initCompositionEvent_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CompositionEvent */,
+          "initCompositionEvent", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  initCompositionEvent_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositionEvent */,
+          "initCompositionEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+}
+
+class BlinkCompositorProxy {
+  static final instance = new BlinkCompositorProxy();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CompositorProxy");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("CompositorProxy", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("CompositorProxy", [__arg_0, __arg_1]);
+
+  opacity_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorProxy */, "opacity");
+
+  opacity_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorProxy */, "opacity", __arg_0);
+
+  scrollLeft_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorProxy */, "scrollLeft");
+
+  scrollLeft_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorProxy */, "scrollLeft", __arg_0);
+
+  scrollTop_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorProxy */, "scrollTop");
+
+  scrollTop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorProxy */, "scrollTop", __arg_0);
+
+  transform_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorProxy */, "transform");
+
+  transform_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorProxy */, "transform", __arg_0);
+
+  disconnect_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorProxy */, "disconnect", []);
+
+  supports_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorProxy */, "supports", []);
+
+  supports_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorProxy */, "supports", [__arg_0]);
+}
+
+class BlinkCompositorWorker extends BlinkEventTarget {
+  static final instance = new BlinkCompositorWorker();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CompositorWorker");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("CompositorWorker", [__arg_0]);
+
+  onmessage_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorWorker */, "onmessage");
+
+  onmessage_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorWorker */, "onmessage", __arg_0);
+
+  postMessage_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorWorker */, "postMessage", []);
+
+  postMessage_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorWorker */, "postMessage", [__arg_0]);
+
+  postMessage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorker */, "postMessage", [__arg_0, __arg_1]);
+
+  terminate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorWorker */, "terminate", []);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* AbstractWorker */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* AbstractWorker */, "onerror", __arg_0);
+}
+
+class BlinkCompositorWorkerGlobalScope extends BlinkWorkerGlobalScope {
+  static final instance = new BlinkCompositorWorkerGlobalScope();
+
+  onmessage_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CompositorWorkerGlobalScope */, "onmessage");
+
+  onmessage_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* CompositorWorkerGlobalScope */, "onmessage", __arg_0);
+
+  cancelAnimationFrame_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */, "cancelAnimationFrame", []);
+
+  cancelAnimationFrame_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */,
+          "cancelAnimationFrame",
+          [__arg_0]);
+
+  postMessage_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CompositorWorkerGlobalScope */, "postMessage", []);
+
+  postMessage_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */, "postMessage", [__arg_0]);
+
+  postMessage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */,
+          "postMessage",
+          [__arg_0, __arg_1]);
+
+  requestAnimationFrame_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */, "requestAnimationFrame", []);
+
+  requestAnimationFrame_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CompositorWorkerGlobalScope */,
+          "requestAnimationFrame",
+          [__arg_0]);
+}
+
+class BlinkConsole extends BlinkConsoleBase {
+  static final instance = new BlinkConsole();
+
+  memory_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Console */, "memory");
+
+  memory_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Console */, "memory", __arg_0);
+}
+
+class BlinkConsoleBase {
+  static final instance = new BlinkConsoleBase();
+
+  assert_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "assert", []);
+
+  assert_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "assert", [__arg_0]);
+
+  assert_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "assert", [__arg_0, __arg_1]);
+
+  clear_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "clear", []);
+
+  clear_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "clear", [__arg_0]);
+
+  count_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "count", []);
+
+  count_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "count", [__arg_0]);
+
+  debug_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "debug", []);
+
+  debug_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "debug", [__arg_0]);
+
+  dir_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "dir", []);
+
+  dir_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "dir", [__arg_0]);
+
+  dirxml_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "dirxml", []);
+
+  dirxml_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "dirxml", [__arg_0]);
+
+  error_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "error", []);
+
+  error_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "error", [__arg_0]);
+
+  group_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "group", []);
+
+  group_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "group", [__arg_0]);
+
+  groupCollapsed_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "groupCollapsed", []);
+
+  groupCollapsed_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "groupCollapsed", [__arg_0]);
+
+  groupEnd_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "groupEnd", []);
+
+  info_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "info", []);
+
+  info_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "info", [__arg_0]);
+
+  log_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "log", []);
+
+  log_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "log", [__arg_0]);
+
+  markTimeline_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "markTimeline", []);
+
+  markTimeline_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "markTimeline", [__arg_0]);
+
+  profile_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "profile", []);
+
+  profile_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "profile", [__arg_0]);
+
+  profileEnd_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "profileEnd", []);
+
+  profileEnd_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "profileEnd", [__arg_0]);
+
+  table_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "table", []);
+
+  table_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "table", [__arg_0]);
+
+  time_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "time", []);
+
+  time_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "time", [__arg_0]);
+
+  timeEnd_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeEnd", []);
+
+  timeEnd_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeEnd", [__arg_0]);
+
+  timeStamp_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeStamp", []);
+
+  timeStamp_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeStamp", [__arg_0]);
+
+  timeline_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeline", []);
+
+  timeline_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timeline", [__arg_0]);
+
+  timelineEnd_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timelineEnd", []);
+
+  timelineEnd_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "timelineEnd", [__arg_0]);
+
+  trace_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "trace", []);
+
+  trace_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "trace", [__arg_0]);
+
+  warn_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "warn", []);
+
+  warn_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ConsoleBase */, "warn", [__arg_0]);
+}
+
+class BlinkConvolverNode extends BlinkAudioNode {
+  static final instance = new BlinkConvolverNode();
+
+  buffer_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ConvolverNode */, "buffer");
+
+  buffer_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ConvolverNode */, "buffer", __arg_0);
+
+  normalize_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ConvolverNode */, "normalize");
+
+  normalize_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* ConvolverNode */, "normalize", __arg_0);
+}
+
+class BlinkCoordinates {
+  static final instance = new BlinkCoordinates();
+
+  accuracy_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "accuracy");
+
+  altitude_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "altitude");
+
+  altitudeAccuracy_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "altitudeAccuracy");
+
+  heading_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "heading");
+
+  latitude_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "latitude");
+
+  longitude_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Coordinates */, "longitude");
+
+  speed_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Coordinates */, "speed");
+}
+
+class BlinkCredential {
+  static final instance = new BlinkCredential();
+
+  iconURL_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Credential */, "iconURL");
+
+  id_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Credential */, "id");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Credential */, "name");
+
+  type_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Credential */, "type");
+}
+
+class BlinkCredentialsContainer {
+  static final instance = new BlinkCredentialsContainer();
+
+  notifySignedIn_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CredentialsContainer */, "notifySignedIn", []);
+
+  notifySignedIn_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CredentialsContainer */, "notifySignedIn", [__arg_0]);
+
+  request_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CredentialsContainer */, "request", []);
+
+  request_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* CredentialsContainer */, "request", [__arg_0]);
+
+  requireUserMediation_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CredentialsContainer */, "requireUserMediation", []);
+}
+
+class BlinkCrossOriginConnectEvent extends BlinkEvent {
+  static final instance = new BlinkCrossOriginConnectEvent();
+
+  client_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CrossOriginConnectEvent */, "client");
+
+  acceptConnection_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* CrossOriginConnectEvent */, "acceptConnection", []);
+
+  acceptConnection_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CrossOriginConnectEvent */, "acceptConnection", [__arg_0]);
+}
+
+class BlinkCrossOriginServiceWorkerClient extends BlinkEventTarget {
+  static final instance = new BlinkCrossOriginServiceWorkerClient();
+
+  origin_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CrossOriginServiceWorkerClient */, "origin");
+
+  targetUrl_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CrossOriginServiceWorkerClient */, "targetUrl");
+
+  postMessage_Callback_0_(mthis) => Blink_JsNative_DomException.callMethod(
+      mthis /* CrossOriginServiceWorkerClient */, "postMessage", []);
+
+  postMessage_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CrossOriginServiceWorkerClient */, "postMessage", [__arg_0]);
+
+  postMessage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CrossOriginServiceWorkerClient */,
+          "postMessage",
+          [__arg_0, __arg_1]);
+}
+
+class BlinkCrypto {
+  static final instance = new BlinkCrypto();
+
+  subtle_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Crypto */, "subtle");
+
+  getRandomValues_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Crypto */, "getRandomValues", []);
+
+  getRandomValues_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Crypto */, "getRandomValues", [__arg_0]);
+}
+
+class BlinkCryptoKey {
+  static final instance = new BlinkCryptoKey();
+
+  algorithm_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CryptoKey */, "algorithm");
+
+  extractable_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CryptoKey */, "extractable");
+
+  type_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CryptoKey */, "type");
+
+  usages_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* CryptoKey */, "usages");
+}
+
+class BlinkCustomEvent extends BlinkEvent {
+  static final instance = new BlinkCustomEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("CustomEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("CustomEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("CustomEvent", [__arg_0, __arg_1]);
+
+  detail_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* CustomEvent */, "detail");
+
+  initCustomEvent_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* CustomEvent */, "initCustomEvent", [__arg_0, __arg_1]);
+
+  initCustomEvent_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CustomEvent */,
+          "initCustomEvent", [__arg_0, __arg_1, __arg_2]);
+
+  initCustomEvent_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* CustomEvent */,
+          "initCustomEvent", [__arg_0, __arg_1, __arg_2, __arg_3]);
+}
+
+class BlinkDOMError {
+  static final instance = new BlinkDOMError();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DOMError");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("DOMError", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DOMError", [__arg_0, __arg_1]);
+
+  message_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMError */, "message");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMError */, "name");
+}
+
+class BlinkDOMException {
+  static final instance = new BlinkDOMException();
+
+  code_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMException */, "code");
+
+  message_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMException */, "message");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMException */, "name");
+
+  toString_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMException */, "toString", []);
+}
+
+class BlinkDOMFileSystem {
+  static final instance = new BlinkDOMFileSystem();
+
+  name_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMFileSystem */, "name");
+
+  root_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMFileSystem */, "root");
+}
+
+class BlinkDOMFileSystemSync {
+  static final instance = new BlinkDOMFileSystemSync();
+
+  name_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMFileSystemSync */, "name");
+
+  root_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMFileSystemSync */, "root");
+}
+
+class BlinkDOMImplementation {
+  static final instance = new BlinkDOMImplementation();
+
+  createDocument_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMImplementation */, "createDocument", [__arg_0]);
+
+  createDocument_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMImplementation */, "createDocument", [__arg_0, __arg_1]);
+
+  createDocument_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMImplementation */,
+          "createDocument", [__arg_0, __arg_1, __arg_2]);
+
+  createDocumentType_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMImplementation */, "createDocumentType", [__arg_0]);
+
+  createDocumentType_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMImplementation */,
+          "createDocumentType", [__arg_0, __arg_1]);
+
+  createDocumentType_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMImplementation */,
+          "createDocumentType", [__arg_0, __arg_1, __arg_2]);
+
+  createHTMLDocument_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMImplementation */, "createHTMLDocument", []);
+
+  createHTMLDocument_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMImplementation */, "createHTMLDocument", [__arg_0]);
+
+  hasFeature_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMImplementation */, "hasFeature", []);
+}
+
+class BlinkDOMMatrix extends BlinkDOMMatrixReadOnly {
+  static final instance = new BlinkDOMMatrix();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DOMMatrix");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("DOMMatrix", [__arg_0]);
+
+  a_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "a");
+
+  a_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "a", __arg_0);
+
+  b_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "b");
+
+  b_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "b", __arg_0);
+
+  c_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "c");
+
+  c_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "c", __arg_0);
+
+  d_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "d");
+
+  d_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "d", __arg_0);
+
+  e_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "e");
+
+  e_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "e", __arg_0);
+
+  f_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "f");
+
+  f_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "f", __arg_0);
+
+  m11_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m11");
+
+  m11_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m11", __arg_0);
+
+  m12_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m12");
+
+  m12_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m12", __arg_0);
+
+  m13_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m13");
+
+  m13_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m13", __arg_0);
+
+  m14_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m14");
+
+  m14_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m14", __arg_0);
+
+  m21_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m21");
+
+  m21_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m21", __arg_0);
+
+  m22_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m22");
+
+  m22_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m22", __arg_0);
+
+  m23_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m23");
+
+  m23_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m23", __arg_0);
+
+  m24_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m24");
+
+  m24_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m24", __arg_0);
+
+  m31_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m31");
+
+  m31_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m31", __arg_0);
+
+  m32_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m32");
+
+  m32_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m32", __arg_0);
+
+  m33_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m33");
+
+  m33_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m33", __arg_0);
+
+  m34_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m34");
+
+  m34_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m34", __arg_0);
+
+  m41_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m41");
+
+  m41_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m41", __arg_0);
+
+  m42_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m42");
+
+  m42_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m42", __arg_0);
+
+  m43_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m43");
+
+  m43_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m43", __arg_0);
+
+  m44_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMMatrix */, "m44");
+
+  m44_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMMatrix */, "m44", __arg_0);
+
+  multiplySelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "multiplySelf", []);
+
+  multiplySelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "multiplySelf", [__arg_0]);
+
+  preMultiplySelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "preMultiplySelf", []);
+
+  preMultiplySelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "preMultiplySelf", [__arg_0]);
+
+  scale3dSelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scale3dSelf", []);
+
+  scale3dSelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scale3dSelf", [__arg_0]);
+
+  scale3dSelf_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* DOMMatrix */, "scale3dSelf", [__arg_0, __arg_1]);
+
+  scale3dSelf_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */, "scale3dSelf", [__arg_0, __arg_1, __arg_2]);
+
+  scale3dSelf_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrix */,
+          "scale3dSelf", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  scaleNonUniformSelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scaleNonUniformSelf", []);
+
+  scaleNonUniformSelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scaleNonUniformSelf", [__arg_0]);
+
+  scaleNonUniformSelf_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */, "scaleNonUniformSelf", [__arg_0, __arg_1]);
+
+  scaleNonUniformSelf_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrix */,
+          "scaleNonUniformSelf", [__arg_0, __arg_1, __arg_2]);
+
+  scaleNonUniformSelf_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrix */,
+          "scaleNonUniformSelf", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  scaleNonUniformSelf_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrix */,
+          "scaleNonUniformSelf", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  scaleNonUniformSelf_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */,
+          "scaleNonUniformSelf",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  scaleSelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scaleSelf", []);
+
+  scaleSelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scaleSelf", [__arg_0]);
+
+  scaleSelf_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "scaleSelf", [__arg_0, __arg_1]);
+
+  scaleSelf_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */, "scaleSelf", [__arg_0, __arg_1, __arg_2]);
+
+  translateSelf_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "translateSelf", []);
+
+  translateSelf_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrix */, "translateSelf", [__arg_0]);
+
+  translateSelf_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */, "translateSelf", [__arg_0, __arg_1]);
+
+  translateSelf_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrix */, "translateSelf", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkDOMMatrixReadOnly {
+  static final instance = new BlinkDOMMatrixReadOnly();
+
+  a_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "a");
+
+  b_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "b");
+
+  c_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "c");
+
+  d_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "d");
+
+  e_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "e");
+
+  f_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "f");
+
+  is2D_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "is2D");
+
+  isIdentity_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "isIdentity");
+
+  m11_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m11");
+
+  m12_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m12");
+
+  m13_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m13");
+
+  m14_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m14");
+
+  m21_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m21");
+
+  m22_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m22");
+
+  m23_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m23");
+
+  m24_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m24");
+
+  m31_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m31");
+
+  m32_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m32");
+
+  m33_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m33");
+
+  m34_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m34");
+
+  m41_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m41");
+
+  m42_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m42");
+
+  m43_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m43");
+
+  m44_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMMatrixReadOnly */, "m44");
+
+  multiply_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "multiply", []);
+
+  multiply_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "multiply", [__arg_0]);
+
+  scale_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale", []);
+
+  scale_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale", [__arg_0]);
+
+  scale_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale", [__arg_0, __arg_1]);
+
+  scale_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrixReadOnly */, "scale", [__arg_0, __arg_1, __arg_2]);
+
+  scale3d_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale3d", []);
+
+  scale3d_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale3d", [__arg_0]);
+
+  scale3d_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scale3d", [__arg_0, __arg_1]);
+
+  scale3d_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "scale3d", [__arg_0, __arg_1, __arg_2]);
+
+  scale3d_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "scale3d", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  scaleNonUniform_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scaleNonUniform", []);
+
+  scaleNonUniform_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "scaleNonUniform", [__arg_0]);
+
+  scaleNonUniform_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrixReadOnly */, "scaleNonUniform", [__arg_0, __arg_1]);
+
+  scaleNonUniform_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "scaleNonUniform", [__arg_0, __arg_1, __arg_2]);
+
+  scaleNonUniform_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "scaleNonUniform", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  scaleNonUniform_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "scaleNonUniform", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  scaleNonUniform_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrixReadOnly */,
+          "scaleNonUniform",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  toFloat32Array_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "toFloat32Array", []);
+
+  toFloat64Array_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "toFloat64Array", []);
+
+  translate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "translate", []);
+
+  translate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMMatrixReadOnly */, "translate", [__arg_0]);
+
+  translate_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMMatrixReadOnly */, "translate", [__arg_0, __arg_1]);
+
+  translate_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DOMMatrixReadOnly */,
+          "translate", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkDOMParser {
+  static final instance = new BlinkDOMParser();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DOMParser");
+
+  parseFromString_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMParser */, "parseFromString", []);
+
+  parseFromString_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMParser */, "parseFromString", [__arg_0]);
+
+  parseFromString_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMParser */, "parseFromString", [__arg_0, __arg_1]);
+}
+
+class BlinkDOMPoint extends BlinkDOMPointReadOnly {
+  static final instance = new BlinkDOMPoint();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DOMPoint");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("DOMPoint", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DOMPoint", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMPoint", [__arg_0, __arg_1, __arg_2]);
+
+  constructorCallback_4_(__arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMPoint", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  w_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMPoint */, "w");
+
+  w_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMPoint */, "w", __arg_0);
+
+  x_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMPoint */, "x");
+
+  x_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMPoint */, "x", __arg_0);
+
+  y_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMPoint */, "y");
+
+  y_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMPoint */, "y", __arg_0);
+
+  z_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMPoint */, "z");
+
+  z_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMPoint */, "z", __arg_0);
+}
+
+class BlinkDOMPointReadOnly {
+  static final instance = new BlinkDOMPointReadOnly();
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DOMPointReadOnly", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMPointReadOnly", [__arg_0, __arg_1, __arg_2]);
+
+  constructorCallback_4_(__arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callConstructor(
+          "DOMPointReadOnly", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  w_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMPointReadOnly */, "w");
+
+  x_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMPointReadOnly */, "x");
+
+  y_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMPointReadOnly */, "y");
+
+  z_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMPointReadOnly */, "z");
+}
+
+class BlinkDOMRect extends BlinkDOMRectReadOnly {
+  static final instance = new BlinkDOMRect();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DOMRect");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("DOMRect", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DOMRect", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMRect", [__arg_0, __arg_1, __arg_2]);
+
+  constructorCallback_4_(__arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMRect", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  height_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRect */, "height");
+
+  height_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMRect */, "height", __arg_0);
+
+  width_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRect */, "width");
+
+  width_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMRect */, "width", __arg_0);
+
+  x_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRect */, "x");
+
+  x_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMRect */, "x", __arg_0);
+
+  y_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRect */, "y");
+
+  y_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMRect */, "y", __arg_0);
+}
+
+class BlinkDOMRectReadOnly {
+  static final instance = new BlinkDOMRectReadOnly();
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DOMRectReadOnly", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("DOMRectReadOnly", [__arg_0, __arg_1, __arg_2]);
+
+  constructorCallback_4_(__arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callConstructor(
+          "DOMRectReadOnly", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  bottom_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "bottom");
+
+  height_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "height");
+
+  left_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "left");
+
+  right_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "right");
+
+  top_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "top");
+
+  width_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMRectReadOnly */, "width");
+
+  x_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRectReadOnly */, "x");
+
+  y_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DOMRectReadOnly */, "y");
+}
+
+class BlinkDOMSettableTokenList extends BlinkDOMTokenList {
+  static final instance = new BlinkDOMSettableTokenList();
+
+  value_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMSettableTokenList */, "value");
+
+  value_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DOMSettableTokenList */, "value", __arg_0);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMSettableTokenList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMSettableTokenList */, "item", [__arg_0]);
+}
+
+class BlinkDOMStringList {
+  static final instance = new BlinkDOMStringList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMStringList */, "length");
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringList */, "__getter__", [__arg_0]);
+
+  contains_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringList */, "contains", []);
+
+  contains_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringList */, "contains", [__arg_0]);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringList */, "item", [__arg_0]);
+}
+
+class BlinkDOMStringMap {
+  static final instance = new BlinkDOMStringMap();
+
+  $__delete___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringMap */, "__delete__", [__arg_0]);
+
+  $__getter___Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringMap */, "__getter__", [__arg_0]);
+
+  $__setter___Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DOMStringMap */, "__setter__", [__arg_0, __arg_1]);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringMap */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMStringMap */, "item", [__arg_0]);
+}
+
+class BlinkDOMTokenList {
+  static final instance = new BlinkDOMTokenList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DOMTokenList */, "length");
+
+  add_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "add", []);
+
+  add_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "add", [__arg_0]);
+
+  contains_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "contains", []);
+
+  contains_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "contains", [__arg_0]);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "item", [__arg_0]);
+
+  remove_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "remove", []);
+
+  remove_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "remove", [__arg_0]);
+
+  toggle_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "toggle", []);
+
+  toggle_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "toggle", [__arg_0]);
+
+  toggle_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DOMTokenList */, "toggle", [__arg_0, __arg_1]);
+}
+
+class BlinkDataTransfer {
+  static final instance = new BlinkDataTransfer();
+
+  dropEffect_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransfer */, "dropEffect");
+
+  dropEffect_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DataTransfer */, "dropEffect", __arg_0);
+
+  effectAllowed_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransfer */, "effectAllowed");
+
+  effectAllowed_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* DataTransfer */, "effectAllowed", __arg_0);
+
+  files_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransfer */, "files");
+
+  items_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransfer */, "items");
+
+  types_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransfer */, "types");
+
+  clearData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "clearData", []);
+
+  clearData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "clearData", [__arg_0]);
+
+  getData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "getData", []);
+
+  getData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "getData", [__arg_0]);
+
+  setData_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "setData", []);
+
+  setData_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "setData", [__arg_0]);
+
+  setData_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "setData", [__arg_0, __arg_1]);
+
+  setDragImage_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransfer */, "setDragImage", [__arg_0]);
+
+  setDragImage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DataTransfer */, "setDragImage", [__arg_0, __arg_1]);
+
+  setDragImage_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DataTransfer */,
+          "setDragImage", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkDataTransferItem {
+  static final instance = new BlinkDataTransferItem();
+
+  kind_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransferItem */, "kind");
+
+  type_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransferItem */, "type");
+
+  getAsFile_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItem */, "getAsFile", []);
+
+  getAsString_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItem */, "getAsString", []);
+
+  getAsString_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItem */, "getAsString", [__arg_0]);
+
+  webkitGetAsEntry_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItem */, "webkitGetAsEntry", []);
+}
+
+class BlinkDataTransferItemList {
+  static final instance = new BlinkDataTransferItemList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DataTransferItemList */, "length");
+
+  add_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "add", []);
+
+  add_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "add", [__arg_0]);
+
+  add_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "add", [__arg_0, __arg_1]);
+
+  clear_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "clear", []);
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "item", [__arg_0]);
+
+  remove_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "remove", []);
+
+  remove_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DataTransferItemList */, "remove", [__arg_0]);
+}
+
+class BlinkDataView extends BlinkArrayBufferView {
+  static final instance = new BlinkDataView();
+}
+
+class BlinkDatabase {
+  static final instance = new BlinkDatabase();
+
+  version_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Database */, "version");
+
+  changeVersion_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "changeVersion", []);
+
+  changeVersion_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "changeVersion", [__arg_0]);
+
+  changeVersion_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Database */, "changeVersion", [__arg_0, __arg_1]);
+
+  changeVersion_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Database */, "changeVersion", [__arg_0, __arg_1, __arg_2]);
+
+  changeVersion_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Database */,
+          "changeVersion", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  changeVersion_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Database */,
+          "changeVersion", [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  readTransaction_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "readTransaction", []);
+
+  readTransaction_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "readTransaction", [__arg_0]);
+
+  readTransaction_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Database */, "readTransaction", [__arg_0, __arg_1]);
+
+  readTransaction_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Database */, "readTransaction", [__arg_0, __arg_1, __arg_2]);
+
+  transaction_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "transaction", []);
+
+  transaction_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Database */, "transaction", [__arg_0]);
+
+  transaction_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Database */, "transaction", [__arg_0, __arg_1]);
+
+  transaction_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Database */, "transaction", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkDatabaseCallback {
+  static final instance = new BlinkDatabaseCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DatabaseCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DatabaseCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkDedicatedWorkerGlobalScope extends BlinkWorkerGlobalScope {
+  static final instance = new BlinkDedicatedWorkerGlobalScope();
+
+  onmessage_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DedicatedWorkerGlobalScope */, "onmessage");
+
+  onmessage_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* DedicatedWorkerGlobalScope */, "onmessage", __arg_0);
+
+  postMessage_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DedicatedWorkerGlobalScope */, "postMessage", []);
+
+  postMessage_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DedicatedWorkerGlobalScope */, "postMessage", [__arg_0]);
+
+  postMessage_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DedicatedWorkerGlobalScope */,
+          "postMessage",
+          [__arg_0, __arg_1]);
+}
+
+class BlinkDefaultSessionStartEvent extends BlinkEvent {
+  static final instance = new BlinkDefaultSessionStartEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DefaultSessionStartEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("DefaultSessionStartEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DefaultSessionStartEvent", [__arg_0, __arg_1]);
+
+  session_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DefaultSessionStartEvent */, "session");
+}
+
+class BlinkDelayNode extends BlinkAudioNode {
+  static final instance = new BlinkDelayNode();
+
+  delayTime_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DelayNode */, "delayTime");
+}
+
+class BlinkDeprecatedStorageInfo {
+  static final instance = new BlinkDeprecatedStorageInfo();
+
+  queryUsageAndQuota_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DeprecatedStorageInfo */, "queryUsageAndQuota", []);
+
+  queryUsageAndQuota_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeprecatedStorageInfo */, "queryUsageAndQuota", [__arg_0]);
+
+  queryUsageAndQuota_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageInfo */,
+          "queryUsageAndQuota", [__arg_0, __arg_1]);
+
+  queryUsageAndQuota_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageInfo */,
+          "queryUsageAndQuota", [__arg_0, __arg_1, __arg_2]);
+
+  requestQuota_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DeprecatedStorageInfo */, "requestQuota", []);
+
+  requestQuota_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DeprecatedStorageInfo */, "requestQuota", [__arg_0]);
+
+  requestQuota_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageInfo */,
+          "requestQuota", [__arg_0, __arg_1]);
+
+  requestQuota_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageInfo */,
+          "requestQuota", [__arg_0, __arg_1, __arg_2]);
+
+  requestQuota_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageInfo */,
+          "requestQuota", [__arg_0, __arg_1, __arg_2, __arg_3]);
+}
+
+class BlinkDeprecatedStorageQuota {
+  static final instance = new BlinkDeprecatedStorageQuota();
+
+  queryUsageAndQuota_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DeprecatedStorageQuota */, "queryUsageAndQuota", []);
+
+  queryUsageAndQuota_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeprecatedStorageQuota */, "queryUsageAndQuota", [__arg_0]);
+
+  queryUsageAndQuota_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageQuota */,
+          "queryUsageAndQuota", [__arg_0, __arg_1]);
+
+  requestQuota_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DeprecatedStorageQuota */, "requestQuota", []);
+
+  requestQuota_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeprecatedStorageQuota */, "requestQuota", [__arg_0]);
+
+  requestQuota_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageQuota */,
+          "requestQuota", [__arg_0, __arg_1]);
+
+  requestQuota_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DeprecatedStorageQuota */,
+          "requestQuota", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkDeviceAcceleration {
+  static final instance = new BlinkDeviceAcceleration();
+
+  x_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceAcceleration */, "x");
+
+  y_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceAcceleration */, "y");
+
+  z_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceAcceleration */, "z");
+}
+
+class BlinkDeviceLightEvent extends BlinkEvent {
+  static final instance = new BlinkDeviceLightEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DeviceLightEvent");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("DeviceLightEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("DeviceLightEvent", [__arg_0, __arg_1]);
+
+  value_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceLightEvent */, "value");
+}
+
+class BlinkDeviceMotionEvent extends BlinkEvent {
+  static final instance = new BlinkDeviceMotionEvent();
+
+  acceleration_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceMotionEvent */, "acceleration");
+
+  accelerationIncludingGravity_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* DeviceMotionEvent */, "accelerationIncludingGravity");
+
+  interval_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceMotionEvent */, "interval");
+
+  rotationRate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceMotionEvent */, "rotationRate");
+
+  initDeviceMotionEvent_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceMotionEvent */,
+          "initDeviceMotionEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  initDeviceMotionEvent_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceMotionEvent */,
+          "initDeviceMotionEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  initDeviceMotionEvent_Callback_7_(mthis, __arg_0, __arg_1, __arg_2, __arg_3,
+          __arg_4, __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceMotionEvent */,
+          "initDeviceMotionEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+}
+
+class BlinkDeviceOrientationEvent extends BlinkEvent {
+  static final instance = new BlinkDeviceOrientationEvent();
+
+  absolute_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceOrientationEvent */, "absolute");
+
+  alpha_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceOrientationEvent */, "alpha");
+
+  beta_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceOrientationEvent */, "beta");
+
+  gamma_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceOrientationEvent */, "gamma");
+
+  initDeviceOrientationEvent_Callback_5_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceOrientationEvent */,
+          "initDeviceOrientationEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  initDeviceOrientationEvent_Callback_6_(
+          mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceOrientationEvent */,
+          "initDeviceOrientationEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5]);
+
+  initDeviceOrientationEvent_Callback_7_(mthis, __arg_0, __arg_1, __arg_2,
+          __arg_3, __arg_4, __arg_5, __arg_6) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DeviceOrientationEvent */,
+          "initDeviceOrientationEvent",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4, __arg_5, __arg_6]);
+}
+
+class BlinkDeviceRotationRate {
+  static final instance = new BlinkDeviceRotationRate();
+
+  alpha_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceRotationRate */, "alpha");
+
+  beta_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceRotationRate */, "beta");
+
+  gamma_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DeviceRotationRate */, "gamma");
+}
+
+class BlinkDirectoryEntry extends BlinkEntry {
+  static final instance = new BlinkDirectoryEntry();
+
+  createReader_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "createReader", []);
+
+  getDirectory_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "getDirectory", []);
+
+  getDirectory_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "getDirectory", [__arg_0]);
+
+  getDirectory_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryEntry */, "getDirectory", [__arg_0, __arg_1]);
+
+  getDirectory_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DirectoryEntry */,
+          "getDirectory", [__arg_0, __arg_1, __arg_2]);
+
+  getDirectory_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DirectoryEntry */,
+          "getDirectory", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  getFile_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "getFile", []);
+
+  getFile_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "getFile", [__arg_0]);
+
+  getFile_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "getFile", [__arg_0, __arg_1]);
+
+  getFile_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryEntry */, "getFile", [__arg_0, __arg_1, __arg_2]);
+
+  getFile_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* DirectoryEntry */,
+          "getFile", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  removeRecursively_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "removeRecursively", []);
+
+  removeRecursively_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntry */, "removeRecursively", [__arg_0]);
+
+  removeRecursively_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryEntry */, "removeRecursively", [__arg_0, __arg_1]);
+}
+
+class BlinkDirectoryEntrySync extends BlinkEntrySync {
+  static final instance = new BlinkDirectoryEntrySync();
+
+  createReader_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "createReader", []);
+
+  getDirectory_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "getDirectory", []);
+
+  getDirectory_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "getDirectory", [__arg_0]);
+
+  getDirectory_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryEntrySync */, "getDirectory", [__arg_0, __arg_1]);
+
+  getFile_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "getFile", []);
+
+  getFile_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "getFile", [__arg_0]);
+
+  getFile_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryEntrySync */, "getFile", [__arg_0, __arg_1]);
+
+  removeRecursively_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryEntrySync */, "removeRecursively", []);
+}
+
+class BlinkDirectoryReader {
+  static final instance = new BlinkDirectoryReader();
+
+  readEntries_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryReader */, "readEntries", []);
+
+  readEntries_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryReader */, "readEntries", [__arg_0]);
+
+  readEntries_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* DirectoryReader */, "readEntries", [__arg_0, __arg_1]);
+}
+
+class BlinkDirectoryReaderSync {
+  static final instance = new BlinkDirectoryReaderSync();
+
+  readEntries_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* DirectoryReaderSync */, "readEntries", []);
+}
+
+class BlinkDocument extends BlinkNode {
+  static final instance = new BlinkDocument();
+
+  URL_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "URL");
+
+  activeElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "activeElement");
+
+  anchors_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "anchors");
+
+  applets_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "applets");
+
+  body_Getter_(mthis) native "Blink_Getter_Document_body";
+
+  body_Setter_(mthis, __arg_0) native "Blink_Setter_Document_body";
+
+  characterSet_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "characterSet");
+
+  charset_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "charset");
+
+  compatMode_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "compatMode");
+
+  contentType_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "contentType");
+
+  cookie_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "cookie");
+
+  cookie_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "cookie", __arg_0);
+
+  currentScript_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "currentScript");
+
+  defaultCharset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "defaultCharset");
+
+  defaultView_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "defaultView");
+
+  designMode_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "designMode");
+
+  designMode_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "designMode", __arg_0);
+
+  dir_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "dir");
+
+  dir_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "dir", __arg_0);
+
+  doctype_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "doctype");
+
+  documentElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "documentElement");
+
+  documentURI_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "documentURI");
+
+  domain_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "domain");
+
+  domain_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "domain", __arg_0);
+
+  embeds_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "embeds");
+
+  fonts_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "fonts");
+
+  forms_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "forms");
+
+  fullscreenElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "fullscreenElement");
+
+  fullscreenEnabled_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "fullscreenEnabled");
+
+  head_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "head");
+
+  hidden_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "hidden");
+
+  images_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "images");
+
+  implementation_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "implementation");
+
+  inputEncoding_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "inputEncoding");
+
+  lastModified_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "lastModified");
+
+  links_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "links");
+
+  location_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "location");
+
+  onbeforecopy_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onbeforecopy");
+
+  onbeforecopy_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onbeforecopy", __arg_0);
+
+  onbeforecut_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onbeforecut");
+
+  onbeforecut_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onbeforecut", __arg_0);
+
+  onbeforepaste_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onbeforepaste");
+
+  onbeforepaste_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onbeforepaste", __arg_0);
+
+  oncopy_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "oncopy");
+
+  oncopy_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "oncopy", __arg_0);
+
+  oncut_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "oncut");
+
+  oncut_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "oncut", __arg_0);
+
+  onfullscreenchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onfullscreenchange");
+
+  onfullscreenchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onfullscreenchange", __arg_0);
+
+  onfullscreenerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onfullscreenerror");
+
+  onfullscreenerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onfullscreenerror", __arg_0);
+
+  onpaste_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "onpaste");
+
+  onpaste_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "onpaste", __arg_0);
+
+  onpointerlockchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onpointerlockchange");
+
+  onpointerlockchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onpointerlockchange", __arg_0);
+
+  onpointerlockerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onpointerlockerror");
+
+  onpointerlockerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onpointerlockerror", __arg_0);
+
+  onreadystatechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onreadystatechange");
+
+  onreadystatechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onreadystatechange", __arg_0);
+
+  onsearch_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "onsearch");
+
+  onsearch_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "onsearch", __arg_0);
+
+  onsecuritypolicyviolation_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "onsecuritypolicyviolation");
+
+  onsecuritypolicyviolation_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* Document */, "onsecuritypolicyviolation", __arg_0);
+
+  onselectionchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onselectionchange");
+
+  onselectionchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onselectionchange", __arg_0);
+
+  onselectstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "onselectstart");
+
+  onselectstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onselectstart", __arg_0);
+
+  ontouchcancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "ontouchcancel");
+
+  ontouchcancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "ontouchcancel", __arg_0);
+
+  ontouchend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "ontouchend");
+
+  ontouchend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "ontouchend", __arg_0);
+
+  ontouchmove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "ontouchmove");
+
+  ontouchmove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "ontouchmove", __arg_0);
+
+  ontouchstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "ontouchstart");
+
+  ontouchstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "ontouchstart", __arg_0);
+
+  onwebkitfullscreenchange_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "onwebkitfullscreenchange");
+
+  onwebkitfullscreenchange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* Document */, "onwebkitfullscreenchange", __arg_0);
+
+  onwebkitfullscreenerror_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "onwebkitfullscreenerror");
+
+  onwebkitfullscreenerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "onwebkitfullscreenerror", __arg_0);
+
+  onwheel_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "onwheel");
+
+  onwheel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "onwheel", __arg_0);
+
+  origin_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "origin");
+
+  plugins_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "plugins");
+
+  pointerLockElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "pointerLockElement");
+
+  preferredStylesheetSet_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "preferredStylesheetSet");
+
+  readyState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "readyState");
+
+  referrer_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "referrer");
+
+  rootElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "rootElement");
+
+  scripts_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "scripts");
+
+  scrollingElement_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "scrollingElement");
+
+  selectedStylesheetSet_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "selectedStylesheetSet");
+
+  selectedStylesheetSet_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "selectedStylesheetSet", __arg_0);
+
+  styleSheets_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "styleSheets");
+
+  timeline_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "timeline");
+
+  title_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Document */, "title");
+
+  title_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "title", __arg_0);
+
+  visibilityState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "visibilityState");
+
+  webkitCurrentFullScreenElement_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "webkitCurrentFullScreenElement");
+
+  webkitFullscreenElement_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "webkitFullscreenElement");
+
+  webkitFullscreenEnabled_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "webkitFullscreenEnabled");
+
+  webkitHidden_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "webkitHidden");
+
+  webkitIsFullScreen_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "webkitIsFullScreen");
+
+  webkitVisibilityState_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Document */, "webkitVisibilityState");
+
+  xmlEncoding_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "xmlEncoding");
+
+  xmlStandalone_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "xmlStandalone");
+
+  xmlStandalone_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Document */, "xmlStandalone", __arg_0);
+
+  xmlVersion_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Document */, "xmlVersion");
+
+  xmlVersion_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Document */, "xmlVersion", __arg_0);
+
+  adoptNode_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "adoptNode", []);
+
+  adoptNode_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "adoptNode", [__arg_0]);
+
+  caretRangeFromPoint_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "caretRangeFromPoint", []);
+
+  caretRangeFromPoint_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "caretRangeFromPoint", [__arg_0]);
+
+  caretRangeFromPoint_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "caretRangeFromPoint", [__arg_0, __arg_1]);
+
+  close_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */, "close", []);
+
+  createAttribute_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createAttribute", []);
+
+  createAttribute_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createAttribute", [__arg_0]);
+
+  createAttributeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createAttributeNS", []);
+
+  createAttributeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createAttributeNS", [__arg_0]);
+
+  createAttributeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createAttributeNS", [__arg_0, __arg_1]);
+
+  createCDATASection_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createCDATASection", []);
+
+  createCDATASection_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createCDATASection", [__arg_0]);
+
+  createComment_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createComment", []);
+
+  createComment_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createComment", [__arg_0]);
+
+  createDocumentFragment_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createDocumentFragment", []);
+
+  createElement_Callback_0_(mthis)
+      native "Blink_Operation_0_Document_createElement";
+
+  createElement_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_Document_createElement"; /* __arg_0 */
+
+  createElement_Callback_2_(mthis, __arg_0, __arg_1)
+      native "Blink_Operation_Document_createElement"; /* __arg_0, __arg_1 */
+
+  createElementNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createElementNS", []);
+
+  createElementNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createElementNS", [__arg_0]);
+
+  createElementNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createElementNS", [__arg_0, __arg_1]);
+
+  createElementNS_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createElementNS", [__arg_0, __arg_1, __arg_2]);
+
+  createEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createEvent", []);
+
+  createEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createEvent", [__arg_0]);
+
+  createExpression_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createExpression", []);
+
+  createExpression_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createExpression", [__arg_0]);
+
+  createExpression_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createExpression", [__arg_0, __arg_1]);
+
+  createNSResolver_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createNSResolver", []);
+
+  createNSResolver_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createNSResolver", [__arg_0]);
+
+  createNodeIterator_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createNodeIterator", []);
+
+  createNodeIterator_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createNodeIterator", [__arg_0]);
+
+  createNodeIterator_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createNodeIterator", [__arg_0, __arg_1]);
+
+  createNodeIterator_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */,
+          "createNodeIterator", [__arg_0, __arg_1, __arg_2]);
+
+  createProcessingInstruction_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createProcessingInstruction", []);
+
+  createProcessingInstruction_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createProcessingInstruction", [__arg_0]);
+
+  createProcessingInstruction_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */,
+          "createProcessingInstruction", [__arg_0, __arg_1]);
+
+  createRange_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createRange", []);
+
+  createTextNode_Callback_0_(mthis)
+      native "Blink_Operation_0_Document_createTextNode";
+
+  createTextNode_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_Document_createTextNode"; /* __arg_0 */
+
+  createTouch_Callback_9_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7, __arg_8) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createTouch", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7,
+        __arg_8
+      ]);
+
+  createTouch_Callback_10_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7, __arg_8, __arg_9) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "createTouch", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7,
+        __arg_8,
+        __arg_9
+      ]);
+
+  createTouch_Callback_11_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4,
+          __arg_5, __arg_6, __arg_7, __arg_8, __arg_9, __arg_10) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "createTouch", [
+        __arg_0,
+        __arg_1,
+        __arg_2,
+        __arg_3,
+        __arg_4,
+        __arg_5,
+        __arg_6,
+        __arg_7,
+        __arg_8,
+        __arg_9,
+        __arg_10
+      ]);
+
+  createTouchList_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createTouchList", []);
+
+  createTouchList_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createTouchList", [__arg_0]);
+
+  createTreeWalker_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createTreeWalker", []);
+
+  createTreeWalker_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "createTreeWalker", [__arg_0]);
+
+  createTreeWalker_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "createTreeWalker", [__arg_0, __arg_1]);
+
+  createTreeWalker_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */,
+          "createTreeWalker", [__arg_0, __arg_1, __arg_2]);
+
+  elementFromPoint_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "elementFromPoint", []);
+
+  elementFromPoint_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "elementFromPoint", [__arg_0]);
+
+  elementFromPoint_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "elementFromPoint", [__arg_0, __arg_1]);
+
+  elementsFromPoint_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "elementsFromPoint", []);
+
+  elementsFromPoint_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "elementsFromPoint", [__arg_0]);
+
+  elementsFromPoint_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "elementsFromPoint", [__arg_0, __arg_1]);
+
+  evaluate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "evaluate", [__arg_0]);
+
+  evaluate_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "evaluate", [__arg_0, __arg_1]);
+
+  evaluate_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "evaluate", [__arg_0, __arg_1, __arg_2]);
+
+  evaluate_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */, "evaluate",
+          [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  evaluate_Callback_5_(mthis, __arg_0, __arg_1, __arg_2, __arg_3, __arg_4) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */, "evaluate",
+          [__arg_0, __arg_1, __arg_2, __arg_3, __arg_4]);
+
+  execCommand_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "execCommand", []);
+
+  execCommand_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "execCommand", [__arg_0]);
+
+  execCommand_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "execCommand", [__arg_0, __arg_1]);
+
+  execCommand_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "execCommand", [__arg_0, __arg_1, __arg_2]);
+
+  exitFullscreen_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "exitFullscreen", []);
+
+  exitPointerLock_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "exitPointerLock", []);
+
+  getCSSCanvasContext_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "getCSSCanvasContext", [__arg_0, __arg_1]);
+
+  getCSSCanvasContext_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */,
+          "getCSSCanvasContext", [__arg_0, __arg_1, __arg_2]);
+
+  getCSSCanvasContext_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */,
+          "getCSSCanvasContext", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  getElementsByClassName_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getElementsByClassName", []);
+
+  getElementsByClassName_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "getElementsByClassName", [__arg_0]);
+
+  getElementsByName_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getElementsByName", []);
+
+  getElementsByName_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getElementsByName", [__arg_0]);
+
+  getElementsByTagName_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getElementsByTagName", []);
+
+  getElementsByTagName_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "getElementsByTagName", [__arg_0]);
+
+  getElementsByTagNameNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getElementsByTagNameNS", []);
+
+  getElementsByTagNameNS_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "getElementsByTagNameNS", [__arg_0]);
+
+  getElementsByTagNameNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "getElementsByTagNameNS", [__arg_0, __arg_1]);
+
+  getSelection_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "getSelection", []);
+
+  hasFocus_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "hasFocus", []);
+
+  importNode_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "importNode", []);
+
+  importNode_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "importNode", [__arg_0]);
+
+  importNode_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "importNode", [__arg_0, __arg_1]);
+
+  open_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */, "open", []);
+
+  queryCommandEnabled_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandEnabled", []);
+
+  queryCommandEnabled_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandEnabled", [__arg_0]);
+
+  queryCommandIndeterm_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandIndeterm", []);
+
+  queryCommandIndeterm_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "queryCommandIndeterm", [__arg_0]);
+
+  queryCommandState_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandState", []);
+
+  queryCommandState_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandState", [__arg_0]);
+
+  queryCommandSupported_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandSupported", []);
+
+  queryCommandSupported_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Document */, "queryCommandSupported", [__arg_0]);
+
+  queryCommandValue_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandValue", []);
+
+  queryCommandValue_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "queryCommandValue", [__arg_0]);
+
+  transformDocumentToTreeView_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "transformDocumentToTreeView", []);
+
+  transformDocumentToTreeView_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Document */, "transformDocumentToTreeView", [__arg_0]);
+
+  webkitCancelFullScreen_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "webkitCancelFullScreen", []);
+
+  webkitExitFullscreen_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "webkitExitFullscreen", []);
+
+  write_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Document */, "write", []);
+
+  write_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "write", [__arg_0]);
+
+  writeln_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "writeln", []);
+
+  writeln_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Document */, "writeln", [__arg_0]);
+
+  onabort_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onabort");
+
+  onabort_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onabort", __arg_0);
+
+  onautocomplete_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocomplete");
+
+  onautocomplete_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onautocomplete", __arg_0);
+
+  onautocompleteerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocompleteerror");
+
+  onautocompleteerror_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onautocompleteerror", __arg_0);
+
+  onblur_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onblur");
+
+  onblur_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onblur", __arg_0);
+
+  oncancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncancel");
+
+  oncancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncancel", __arg_0);
+
+  oncanplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay");
+
+  oncanplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay", __arg_0);
+
+  oncanplaythrough_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplaythrough");
+
+  oncanplaythrough_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "oncanplaythrough", __arg_0);
+
+  onchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onchange");
+
+  onchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onchange", __arg_0);
+
+  onclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclick");
+
+  onclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclick", __arg_0);
+
+  onclose_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclose");
+
+  onclose_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclose", __arg_0);
+
+  oncontextmenu_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncontextmenu");
+
+  oncontextmenu_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncontextmenu", __arg_0);
+
+  oncuechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncuechange");
+
+  oncuechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncuechange", __arg_0);
+
+  ondblclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick");
+
+  ondblclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick", __arg_0);
+
+  ondrag_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrag");
+
+  ondrag_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrag", __arg_0);
+
+  ondragend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragend");
+
+  ondragend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragend", __arg_0);
+
+  ondragenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragenter");
+
+  ondragenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragenter", __arg_0);
+
+  ondragleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragleave");
+
+  ondragleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragleave", __arg_0);
+
+  ondragover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragover");
+
+  ondragover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragover", __arg_0);
+
+  ondragstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragstart");
+
+  ondragstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragstart", __arg_0);
+
+  ondrop_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrop");
+
+  ondrop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrop", __arg_0);
+
+  ondurationchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondurationchange");
+
+  ondurationchange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "ondurationchange", __arg_0);
+
+  onemptied_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onemptied");
+
+  onemptied_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onemptied", __arg_0);
+
+  onended_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onended");
+
+  onended_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onended", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onerror", __arg_0);
+
+  onfocus_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onfocus");
+
+  onfocus_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onfocus", __arg_0);
+
+  oninput_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninput");
+
+  oninput_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninput", __arg_0);
+
+  oninvalid_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid");
+
+  oninvalid_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid", __arg_0);
+
+  onkeydown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown");
+
+  onkeydown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown", __arg_0);
+
+  onkeypress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress");
+
+  onkeypress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress", __arg_0);
+
+  onkeyup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup");
+
+  onkeyup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup", __arg_0);
+
+  onload_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onload");
+
+  onload_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onload", __arg_0);
+
+  onloadeddata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadeddata");
+
+  onloadeddata_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadeddata", __arg_0);
+
+  onloadedmetadata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadedmetadata");
+
+  onloadedmetadata_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onloadedmetadata", __arg_0);
+
+  onloadstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadstart");
+
+  onloadstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadstart", __arg_0);
+
+  onmousedown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousedown");
+
+  onmousedown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousedown", __arg_0);
+
+  onmouseenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseenter");
+
+  onmouseenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseenter", __arg_0);
+
+  onmouseleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseleave");
+
+  onmouseleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseleave", __arg_0);
+
+  onmousemove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousemove");
+
+  onmousemove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousemove", __arg_0);
+
+  onmouseout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout");
+
+  onmouseout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout", __arg_0);
+
+  onmouseover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseover");
+
+  onmouseover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseover", __arg_0);
+
+  onmouseup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup");
+
+  onmouseup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup", __arg_0);
+
+  onmousewheel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousewheel");
+
+  onmousewheel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousewheel", __arg_0);
+
+  onpause_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpause");
+
+  onpause_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onpause", __arg_0);
+
+  onplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplay");
+
+  onplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplay", __arg_0);
+
+  onplaying_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplaying");
+
+  onplaying_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplaying", __arg_0);
+
+  onpointercancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointercancel");
+
+  onpointercancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointercancel", __arg_0);
+
+  onpointerdown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerdown");
+
+  onpointerdown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerdown", __arg_0);
+
+  onpointerenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerenter");
+
+  onpointerenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerenter", __arg_0);
+
+  onpointerleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerleave");
+
+  onpointerleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerleave", __arg_0);
+
+  onpointermove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointermove");
+
+  onpointermove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointermove", __arg_0);
+
+  onpointerout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerout");
+
+  onpointerout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerout", __arg_0);
+
+  onpointerover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerover");
+
+  onpointerover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerover", __arg_0);
+
+  onpointerup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerup");
+
+  onpointerup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerup", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onprogress", __arg_0);
+
+  onratechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onratechange");
+
+  onratechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onratechange", __arg_0);
+
+  onreset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onreset");
+
+  onreset_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onreset", __arg_0);
+
+  onresize_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onresize");
+
+  onresize_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onresize", __arg_0);
+
+  onscroll_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onscroll");
+
+  onscroll_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onscroll", __arg_0);
+
+  onseeked_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeked");
+
+  onseeked_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeked", __arg_0);
+
+  onseeking_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeking");
+
+  onseeking_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeking", __arg_0);
+
+  onselect_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onselect");
+
+  onselect_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onselect", __arg_0);
+
+  onshow_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onshow");
+
+  onshow_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onshow", __arg_0);
+
+  onstalled_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onstalled");
+
+  onstalled_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onstalled", __arg_0);
+
+  onsubmit_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit");
+
+  onsubmit_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit", __arg_0);
+
+  onsuspend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend");
+
+  onsuspend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend", __arg_0);
+
+  ontimeupdate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontimeupdate");
+
+  ontimeupdate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ontimeupdate", __arg_0);
+
+  ontoggle_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle");
+
+  ontoggle_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle", __arg_0);
+
+  onvolumechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onvolumechange");
+
+  onvolumechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onvolumechange", __arg_0);
+
+  onwaiting_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting");
+
+  onwaiting_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting", __arg_0);
+
+  childElementCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ParentNode */, "childElementCount");
+
+  children_Getter_(mthis) native "Blink_Getter_ParentNode_children";
+
+  firstElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_firstElementChild";
+
+  lastElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_lastElementChild";
+
+  append_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", []);
+
+  append_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", [__arg_0]);
+
+  prepend_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", []);
+
+  prepend_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", [__arg_0]);
+
+  querySelector_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", []);
+
+  querySelector_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", [__arg_0]);
+
+  querySelectorAll_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", []);
+
+  querySelectorAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", [__arg_0]);
+
+  getElementById_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* NonElementParentNode */, "getElementById", []);
+
+  getElementById_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* NonElementParentNode */, "getElementById", [__arg_0]);
+}
+
+class BlinkDocumentFragment extends BlinkNode {
+  static final instance = new BlinkDocumentFragment();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("DocumentFragment");
+
+  childElementCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ParentNode */, "childElementCount");
+
+  children_Getter_(mthis) native "Blink_Getter_ParentNode_children";
+
+  firstElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_firstElementChild";
+
+  lastElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_lastElementChild";
+
+  append_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", []);
+
+  append_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", [__arg_0]);
+
+  prepend_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", []);
+
+  prepend_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", [__arg_0]);
+
+  querySelector_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", []);
+
+  querySelector_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", [__arg_0]);
+
+  querySelectorAll_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", []);
+
+  querySelectorAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", [__arg_0]);
+
+  getElementById_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* NonElementParentNode */, "getElementById", []);
+
+  getElementById_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* NonElementParentNode */, "getElementById", [__arg_0]);
+}
+
+class BlinkDocumentType extends BlinkNode {
+  static final instance = new BlinkDocumentType();
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* DocumentType */, "name");
+
+  publicId_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DocumentType */, "publicId");
+
+  systemId_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DocumentType */, "systemId");
+
+  after_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", []);
+
+  after_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", [__arg_0]);
+
+  before_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", []);
+
+  before_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", [__arg_0]);
+
+  remove_Callback_0_(mthis) native "Blink_Operation_0_ChildNode_remove";
+
+  replaceWith_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", []);
+
+  replaceWith_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", [__arg_0]);
+}
+
+class BlinkDynamicsCompressorNode extends BlinkAudioNode {
+  static final instance = new BlinkDynamicsCompressorNode();
+
+  attack_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "attack");
+
+  knee_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "knee");
+
+  ratio_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "ratio");
+
+  reduction_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "reduction");
+
+  release_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "release");
+
+  threshold_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* DynamicsCompressorNode */, "threshold");
+}
+
+class BlinkEXTBlendMinMax {
+  static final instance = new BlinkEXTBlendMinMax();
+}
+
+class BlinkEXTFragDepth {
+  static final instance = new BlinkEXTFragDepth();
+}
+
+class BlinkEXTShaderTextureLOD {
+  static final instance = new BlinkEXTShaderTextureLOD();
+}
+
+class BlinkEXTTextureFilterAnisotropic {
+  static final instance = new BlinkEXTTextureFilterAnisotropic();
+}
+
+class BlinkEXTsRGB {
+  static final instance = new BlinkEXTsRGB();
+}
+
+class BlinkEffectModel {
+  static final instance = new BlinkEffectModel();
+}
+
+class BlinkElement extends BlinkNode {
+  static final instance = new BlinkElement();
+
+  attributes_Getter_(mthis) native "Blink_Getter_Element_attributes";
+
+  classList_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "classList");
+
+  className_Getter_(mthis) native "Blink_Getter_Element_className";
+
+  className_Setter_(mthis, __arg_0) native "Blink_Setter_Element_className";
+
+  clientHeight_Getter_(mthis) native "Blink_Getter_Element_clientHeight";
+
+  clientLeft_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "clientLeft");
+
+  clientTop_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "clientTop");
+
+  clientWidth_Getter_(mthis) native "Blink_Getter_Element_clientWidth";
+
+  computedName_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "computedName");
+
+  computedRole_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "computedRole");
+
+  id_Getter_(mthis) native "Blink_Getter_Element_id";
+
+  id_Setter_(mthis, __arg_0) native "Blink_Setter_Element_id";
+
+  innerHTML_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "innerHTML");
+
+  innerHTML_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "innerHTML", __arg_0);
+
+  localName_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "localName");
+
+  namespaceURI_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "namespaceURI");
+
+  offsetHeight_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "offsetHeight");
+
+  offsetLeft_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "offsetLeft");
+
+  offsetParent_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "offsetParent");
+
+  offsetTop_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "offsetTop");
+
+  offsetWidth_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "offsetWidth");
+
+  onbeforecopy_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "onbeforecopy");
+
+  onbeforecopy_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "onbeforecopy", __arg_0);
+
+  onbeforecut_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "onbeforecut");
+
+  onbeforecut_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "onbeforecut", __arg_0);
+
+  onbeforepaste_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "onbeforepaste");
+
+  onbeforepaste_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "onbeforepaste", __arg_0);
+
+  oncopy_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "oncopy");
+
+  oncopy_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "oncopy", __arg_0);
+
+  oncut_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "oncut");
+
+  oncut_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "oncut", __arg_0);
+
+  onpaste_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "onpaste");
+
+  onpaste_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "onpaste", __arg_0);
+
+  onsearch_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "onsearch");
+
+  onsearch_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "onsearch", __arg_0);
+
+  onselectstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "onselectstart");
+
+  onselectstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "onselectstart", __arg_0);
+
+  ontouchcancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "ontouchcancel");
+
+  ontouchcancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "ontouchcancel", __arg_0);
+
+  ontouchend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "ontouchend");
+
+  ontouchend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "ontouchend", __arg_0);
+
+  ontouchmove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "ontouchmove");
+
+  ontouchmove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "ontouchmove", __arg_0);
+
+  ontouchstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "ontouchstart");
+
+  ontouchstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "ontouchstart", __arg_0);
+
+  onwebkitfullscreenchange_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Element */, "onwebkitfullscreenchange");
+
+  onwebkitfullscreenchange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* Element */, "onwebkitfullscreenchange", __arg_0);
+
+  onwebkitfullscreenerror_Getter_(mthis) => Blink_JsNative_DomException
+      .getProperty(mthis /* Element */, "onwebkitfullscreenerror");
+
+  onwebkitfullscreenerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Element */, "onwebkitfullscreenerror", __arg_0);
+
+  onwheel_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "onwheel");
+
+  onwheel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "onwheel", __arg_0);
+
+  outerHTML_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "outerHTML");
+
+  outerHTML_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "outerHTML", __arg_0);
+
+  prefix_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "prefix");
+
+  scrollHeight_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "scrollHeight");
+
+  scrollLeft_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "scrollLeft");
+
+  scrollLeft_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "scrollLeft", __arg_0);
+
+  scrollTop_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Element */, "scrollTop");
+
+  scrollTop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* Element */, "scrollTop", __arg_0);
+
+  scrollWidth_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "scrollWidth");
+
+  shadowRoot_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Element */, "shadowRoot");
+
+  tagName_Getter_(mthis) native "Blink_Getter_Element_tagName";
+
+  animate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "animate", []);
+
+  animate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "animate", [__arg_0]);
+
+  animate_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "animate", [__arg_0, __arg_1]);
+
+  closest_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "closest", []);
+
+  closest_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "closest", [__arg_0]);
+
+  createShadowRoot_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "createShadowRoot", []);
+
+  createShadowRoot_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "createShadowRoot", [__arg_0]);
+
+  getAnimations_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAnimations", []);
+
+  getAttribute_Callback_0_(mthis)
+      native "Blink_Operation_0_Element_getAttribute";
+
+  getAttribute_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_Element_getAttribute"; /* __arg_0 */
+
+  getAttributeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNS", []);
+
+  getAttributeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNS", [__arg_0]);
+
+  getAttributeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "getAttributeNS", [__arg_0, __arg_1]);
+
+  getAttributeNode_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNode", []);
+
+  getAttributeNode_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNode", [__arg_0]);
+
+  getAttributeNodeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNodeNS", []);
+
+  getAttributeNodeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getAttributeNodeNS", [__arg_0]);
+
+  getAttributeNodeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "getAttributeNodeNS", [__arg_0, __arg_1]);
+
+  getBoundingClientRect_Callback_0_(mthis)
+      native "Blink_Operation_0_Element_getBoundingClientRect";
+
+  getClientRects_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getClientRects", []);
+
+  getDestinationInsertionPoints_Callback_0_(mthis) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "getDestinationInsertionPoints", []);
+
+  getElementsByClassName_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getElementsByClassName", []);
+
+  getElementsByClassName_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "getElementsByClassName", [__arg_0]);
+
+  getElementsByTagName_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getElementsByTagName", []);
+
+  getElementsByTagName_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "getElementsByTagName", [__arg_0]);
+
+  getElementsByTagNameNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "getElementsByTagNameNS", []);
+
+  getElementsByTagNameNS_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "getElementsByTagNameNS", [__arg_0]);
+
+  getElementsByTagNameNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "getElementsByTagNameNS", [__arg_0, __arg_1]);
+
+  hasAttribute_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "hasAttribute", []);
+
+  hasAttribute_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "hasAttribute", [__arg_0]);
+
+  hasAttributeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "hasAttributeNS", []);
+
+  hasAttributeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "hasAttributeNS", [__arg_0]);
+
+  hasAttributeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "hasAttributeNS", [__arg_0, __arg_1]);
+
+  hasAttributes_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "hasAttributes", []);
+
+  insertAdjacentElement_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "insertAdjacentElement", []);
+
+  insertAdjacentElement_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "insertAdjacentElement", [__arg_0]);
+
+  insertAdjacentElement_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "insertAdjacentElement", [__arg_0, __arg_1]);
+
+  insertAdjacentHTML_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "insertAdjacentHTML", []);
+
+  insertAdjacentHTML_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "insertAdjacentHTML", [__arg_0]);
+
+  insertAdjacentHTML_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "insertAdjacentHTML", [__arg_0, __arg_1]);
+
+  insertAdjacentText_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "insertAdjacentText", []);
+
+  insertAdjacentText_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "insertAdjacentText", [__arg_0]);
+
+  insertAdjacentText_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "insertAdjacentText", [__arg_0, __arg_1]);
+
+  matches_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "matches", []);
+
+  matches_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "matches", [__arg_0]);
+
+  removeAttribute_Callback_0_(mthis)
+      native "Blink_Operation_0_Element_removeAttribute";
+
+  removeAttribute_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_Element_removeAttribute"; /* __arg_0 */
+
+  removeAttributeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "removeAttributeNS", []);
+
+  removeAttributeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "removeAttributeNS", [__arg_0]);
+
+  removeAttributeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "removeAttributeNS", [__arg_0, __arg_1]);
+
+  removeAttributeNode_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "removeAttributeNode", []);
+
+  removeAttributeNode_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "removeAttributeNode", [__arg_0]);
+
+  requestFullscreen_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "requestFullscreen", []);
+
+  requestPointerLock_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "requestPointerLock", []);
+
+  scroll_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Element */, "scroll", []);
+
+  scroll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scroll", [__arg_0]);
+
+  scroll_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scroll", [__arg_0, __arg_1]);
+
+  scrollBy_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollBy", []);
+
+  scrollBy_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollBy", [__arg_0]);
+
+  scrollBy_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollBy", [__arg_0, __arg_1]);
+
+  scrollIntoView_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollIntoView", []);
+
+  scrollIntoView_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollIntoView", [__arg_0]);
+
+  scrollIntoViewIfNeeded_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollIntoViewIfNeeded", []);
+
+  scrollIntoViewIfNeeded_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "scrollIntoViewIfNeeded", [__arg_0]);
+
+  scrollTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollTo", []);
+
+  scrollTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollTo", [__arg_0]);
+
+  scrollTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "scrollTo", [__arg_0, __arg_1]);
+
+  setAttribute_Callback_0_(mthis)
+      native "Blink_Operation_0_Element_setAttribute";
+
+  setAttribute_Callback_1_(mthis, __arg_0)
+      native "Blink_Operation_Element_setAttribute"; /* __arg_0 */
+
+  setAttribute_Callback_2_(mthis, __arg_0, __arg_1)
+      native "Blink_Operation_Element_setAttribute"; /* __arg_0, __arg_1 */
+
+  setAttributeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "setAttributeNS", [__arg_0]);
+
+  setAttributeNS_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "setAttributeNS", [__arg_0, __arg_1]);
+
+  setAttributeNS_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Element */, "setAttributeNS", [__arg_0, __arg_1, __arg_2]);
+
+  setAttributeNode_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "setAttributeNode", []);
+
+  setAttributeNode_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "setAttributeNode", [__arg_0]);
+
+  setAttributeNodeNS_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "setAttributeNodeNS", []);
+
+  setAttributeNodeNS_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "setAttributeNodeNS", [__arg_0]);
+
+  webkitMatchesSelector_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "webkitMatchesSelector", []);
+
+  webkitMatchesSelector_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Element */, "webkitMatchesSelector", [__arg_0]);
+
+  webkitRequestFullScreen_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Element */, "webkitRequestFullScreen", []);
+
+  childElementCount_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ParentNode */, "childElementCount");
+
+  children_Getter_(mthis) native "Blink_Getter_ParentNode_children";
+
+  firstElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_firstElementChild";
+
+  lastElementChild_Getter_(mthis)
+      native "Blink_Getter_ParentNode_lastElementChild";
+
+  append_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", []);
+
+  append_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "append", [__arg_0]);
+
+  prepend_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", []);
+
+  prepend_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "prepend", [__arg_0]);
+
+  querySelector_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", []);
+
+  querySelector_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelector", [__arg_0]);
+
+  querySelectorAll_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", []);
+
+  querySelectorAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ParentNode */, "querySelectorAll", [__arg_0]);
+
+  after_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", []);
+
+  after_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "after", [__arg_0]);
+
+  before_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", []);
+
+  before_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "before", [__arg_0]);
+
+  remove_Callback_0_(mthis) native "Blink_Operation_0_ChildNode_remove";
+
+  replaceWith_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", []);
+
+  replaceWith_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ChildNode */, "replaceWith", [__arg_0]);
+
+  nextElementSibling_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* NonDocumentTypeChildNode */, "nextElementSibling");
+
+  previousElementSibling_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(
+          mthis /* NonDocumentTypeChildNode */, "previousElementSibling");
+
+  onabort_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onabort");
+
+  onabort_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onabort", __arg_0);
+
+  onautocomplete_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocomplete");
+
+  onautocomplete_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onautocomplete", __arg_0);
+
+  onautocompleteerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocompleteerror");
+
+  onautocompleteerror_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onautocompleteerror", __arg_0);
+
+  onblur_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onblur");
+
+  onblur_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onblur", __arg_0);
+
+  oncancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncancel");
+
+  oncancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncancel", __arg_0);
+
+  oncanplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay");
+
+  oncanplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay", __arg_0);
+
+  oncanplaythrough_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplaythrough");
+
+  oncanplaythrough_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "oncanplaythrough", __arg_0);
+
+  onchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onchange");
+
+  onchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onchange", __arg_0);
+
+  onclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclick");
+
+  onclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclick", __arg_0);
+
+  onclose_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclose");
+
+  onclose_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclose", __arg_0);
+
+  oncontextmenu_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncontextmenu");
+
+  oncontextmenu_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncontextmenu", __arg_0);
+
+  oncuechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncuechange");
+
+  oncuechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncuechange", __arg_0);
+
+  ondblclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick");
+
+  ondblclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick", __arg_0);
+
+  ondrag_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrag");
+
+  ondrag_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrag", __arg_0);
+
+  ondragend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragend");
+
+  ondragend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragend", __arg_0);
+
+  ondragenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragenter");
+
+  ondragenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragenter", __arg_0);
+
+  ondragleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragleave");
+
+  ondragleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragleave", __arg_0);
+
+  ondragover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragover");
+
+  ondragover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragover", __arg_0);
+
+  ondragstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragstart");
+
+  ondragstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragstart", __arg_0);
+
+  ondrop_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrop");
+
+  ondrop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrop", __arg_0);
+
+  ondurationchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondurationchange");
+
+  ondurationchange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "ondurationchange", __arg_0);
+
+  onemptied_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onemptied");
+
+  onemptied_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onemptied", __arg_0);
+
+  onended_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onended");
+
+  onended_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onended", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onerror", __arg_0);
+
+  onfocus_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onfocus");
+
+  onfocus_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onfocus", __arg_0);
+
+  oninput_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninput");
+
+  oninput_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninput", __arg_0);
+
+  oninvalid_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid");
+
+  oninvalid_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid", __arg_0);
+
+  onkeydown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown");
+
+  onkeydown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown", __arg_0);
+
+  onkeypress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress");
+
+  onkeypress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress", __arg_0);
+
+  onkeyup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup");
+
+  onkeyup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup", __arg_0);
+
+  onload_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onload");
+
+  onload_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onload", __arg_0);
+
+  onloadeddata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadeddata");
+
+  onloadeddata_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadeddata", __arg_0);
+
+  onloadedmetadata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadedmetadata");
+
+  onloadedmetadata_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onloadedmetadata", __arg_0);
+
+  onloadstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadstart");
+
+  onloadstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadstart", __arg_0);
+
+  onmousedown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousedown");
+
+  onmousedown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousedown", __arg_0);
+
+  onmouseenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseenter");
+
+  onmouseenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseenter", __arg_0);
+
+  onmouseleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseleave");
+
+  onmouseleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseleave", __arg_0);
+
+  onmousemove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousemove");
+
+  onmousemove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousemove", __arg_0);
+
+  onmouseout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout");
+
+  onmouseout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout", __arg_0);
+
+  onmouseover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseover");
+
+  onmouseover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseover", __arg_0);
+
+  onmouseup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup");
+
+  onmouseup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup", __arg_0);
+
+  onmousewheel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousewheel");
+
+  onmousewheel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousewheel", __arg_0);
+
+  onpause_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpause");
+
+  onpause_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onpause", __arg_0);
+
+  onplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplay");
+
+  onplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplay", __arg_0);
+
+  onplaying_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplaying");
+
+  onplaying_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplaying", __arg_0);
+
+  onpointercancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointercancel");
+
+  onpointercancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointercancel", __arg_0);
+
+  onpointerdown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerdown");
+
+  onpointerdown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerdown", __arg_0);
+
+  onpointerenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerenter");
+
+  onpointerenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerenter", __arg_0);
+
+  onpointerleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerleave");
+
+  onpointerleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerleave", __arg_0);
+
+  onpointermove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointermove");
+
+  onpointermove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointermove", __arg_0);
+
+  onpointerout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerout");
+
+  onpointerout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerout", __arg_0);
+
+  onpointerover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerover");
+
+  onpointerover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerover", __arg_0);
+
+  onpointerup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerup");
+
+  onpointerup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerup", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onprogress", __arg_0);
+
+  onratechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onratechange");
+
+  onratechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onratechange", __arg_0);
+
+  onreset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onreset");
+
+  onreset_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onreset", __arg_0);
+
+  onresize_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onresize");
+
+  onresize_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onresize", __arg_0);
+
+  onscroll_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onscroll");
+
+  onscroll_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onscroll", __arg_0);
+
+  onseeked_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeked");
+
+  onseeked_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeked", __arg_0);
+
+  onseeking_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeking");
+
+  onseeking_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeking", __arg_0);
+
+  onselect_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onselect");
+
+  onselect_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onselect", __arg_0);
+
+  onshow_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onshow");
+
+  onshow_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onshow", __arg_0);
+
+  onstalled_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onstalled");
+
+  onstalled_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onstalled", __arg_0);
+
+  onsubmit_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit");
+
+  onsubmit_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit", __arg_0);
+
+  onsuspend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend");
+
+  onsuspend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend", __arg_0);
+
+  ontimeupdate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontimeupdate");
+
+  ontimeupdate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ontimeupdate", __arg_0);
+
+  ontoggle_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle");
+
+  ontoggle_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle", __arg_0);
+
+  onvolumechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onvolumechange");
+
+  onvolumechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onvolumechange", __arg_0);
+
+  onwaiting_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting");
+
+  onwaiting_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting", __arg_0);
+}
+
+class BlinkEntriesCallback {
+  static final instance = new BlinkEntriesCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntriesCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntriesCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkEntry {
+  static final instance = new BlinkEntry();
+
+  filesystem_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Entry */, "filesystem");
+
+  fullPath_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Entry */, "fullPath");
+
+  isDirectory_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Entry */, "isDirectory");
+
+  isFile_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Entry */, "isFile");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Entry */, "name");
+
+  copyTo_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Entry */, "copyTo", []);
+
+  copyTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "copyTo", [__arg_0]);
+
+  copyTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "copyTo", [__arg_0, __arg_1]);
+
+  copyTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Entry */, "copyTo", [__arg_0, __arg_1, __arg_2]);
+
+  copyTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Entry */, "copyTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  getMetadata_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "getMetadata", []);
+
+  getMetadata_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "getMetadata", [__arg_0]);
+
+  getMetadata_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Entry */, "getMetadata", [__arg_0, __arg_1]);
+
+  getParent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "getParent", []);
+
+  getParent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "getParent", [__arg_0]);
+
+  getParent_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "getParent", [__arg_0, __arg_1]);
+
+  moveTo_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Entry */, "moveTo", []);
+
+  moveTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "moveTo", [__arg_0]);
+
+  moveTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "moveTo", [__arg_0, __arg_1]);
+
+  moveTo_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* Entry */, "moveTo", [__arg_0, __arg_1, __arg_2]);
+
+  moveTo_Callback_4_(mthis, __arg_0, __arg_1, __arg_2, __arg_3) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Entry */, "moveTo", [__arg_0, __arg_1, __arg_2, __arg_3]);
+
+  remove_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Entry */, "remove", []);
+
+  remove_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "remove", [__arg_0]);
+
+  remove_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Entry */, "remove", [__arg_0, __arg_1]);
+
+  toURL_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Entry */, "toURL", []);
+}
+
+class BlinkEntryCallback {
+  static final instance = new BlinkEntryCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntryCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntryCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkEntrySync {
+  static final instance = new BlinkEntrySync();
+
+  filesystem_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EntrySync */, "filesystem");
+
+  fullPath_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EntrySync */, "fullPath");
+
+  isDirectory_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EntrySync */, "isDirectory");
+
+  isFile_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* EntrySync */, "isFile");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* EntrySync */, "name");
+
+  copyTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "copyTo", []);
+
+  copyTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "copyTo", [__arg_0]);
+
+  copyTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "copyTo", [__arg_0, __arg_1]);
+
+  getMetadata_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "getMetadata", []);
+
+  getParent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "getParent", []);
+
+  moveTo_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "moveTo", []);
+
+  moveTo_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "moveTo", [__arg_0]);
+
+  moveTo_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "moveTo", [__arg_0, __arg_1]);
+
+  remove_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "remove", []);
+
+  toURL_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EntrySync */, "toURL", []);
+}
+
+class BlinkErrorCallback {
+  static final instance = new BlinkErrorCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ErrorCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ErrorCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkErrorEvent extends BlinkEvent {
+  static final instance = new BlinkErrorEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("ErrorEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("ErrorEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("ErrorEvent", [__arg_0, __arg_1]);
+
+  colno_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ErrorEvent */, "colno");
+
+  error_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ErrorEvent */, "error");
+
+  filename_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ErrorEvent */, "filename");
+
+  lineno_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* ErrorEvent */, "lineno");
+
+  message_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* ErrorEvent */, "message");
+}
+
+class BlinkEvent {
+  static final instance = new BlinkEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("Event");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("Event", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callConstructor("Event", [__arg_0, __arg_1]);
+
+  bubbles_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "bubbles");
+
+  cancelBubble_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Event */, "cancelBubble");
+
+  cancelBubble_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Event */, "cancelBubble", __arg_0);
+
+  cancelable_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "cancelable");
+
+  currentTarget_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Event */, "currentTarget");
+
+  defaultPrevented_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Event */, "defaultPrevented");
+
+  eventPhase_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "eventPhase");
+
+  path_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "path");
+
+  returnValue_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "returnValue");
+
+  returnValue_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* Event */, "returnValue", __arg_0);
+
+  srcElement_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "srcElement");
+
+  target_Getter_(mthis) native "Blink_Getter_Event_target";
+
+  timeStamp_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "timeStamp");
+
+  type_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Event */, "type");
+
+  initEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Event */, "initEvent", [__arg_0]);
+
+  initEvent_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* Event */, "initEvent", [__arg_0, __arg_1]);
+
+  initEvent_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Event */, "initEvent", [__arg_0, __arg_1, __arg_2]);
+
+  preventDefault_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Event */, "preventDefault", []);
+
+  stopImmediatePropagation_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Event */, "stopImmediatePropagation", []);
+
+  stopPropagation_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Event */, "stopPropagation", []);
+}
+
+class BlinkEventListener {
+  static final instance = new BlinkEventListener();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventListener */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventListener */, "handleEvent", [__arg_0]);
+}
+
+class BlinkEventSource extends BlinkEventTarget {
+  static final instance = new BlinkEventSource();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("EventSource");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("EventSource", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("EventSource", [__arg_0, __arg_1]);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EventSource */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* EventSource */, "onerror", __arg_0);
+
+  onmessage_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EventSource */, "onmessage");
+
+  onmessage_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* EventSource */, "onmessage", __arg_0);
+
+  onopen_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EventSource */, "onopen");
+
+  onopen_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* EventSource */, "onopen", __arg_0);
+
+  readyState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EventSource */, "readyState");
+
+  url_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* EventSource */, "url");
+
+  withCredentials_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* EventSource */, "withCredentials");
+
+  close_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventSource */, "close", []);
+}
+
+class BlinkEventTarget {
+  static final instance = new BlinkEventTarget();
+
+  addEventListener_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "addEventListener", []);
+
+  addEventListener_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "addEventListener", [__arg_0]);
+
+  addEventListener_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* EventTarget */, "addEventListener", [__arg_0, __arg_1]);
+
+  addEventListener_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* EventTarget */,
+          "addEventListener", [__arg_0, __arg_1, __arg_2]);
+
+  dispatchEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "dispatchEvent", []);
+
+  dispatchEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "dispatchEvent", [__arg_0]);
+
+  removeEventListener_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "removeEventListener", []);
+
+  removeEventListener_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* EventTarget */, "removeEventListener", [__arg_0]);
+
+  removeEventListener_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* EventTarget */, "removeEventListener", [__arg_0, __arg_1]);
+
+  removeEventListener_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* EventTarget */,
+          "removeEventListener", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkExtendableEvent extends BlinkEvent {
+  static final instance = new BlinkExtendableEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("ExtendableEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("ExtendableEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("ExtendableEvent", [__arg_0, __arg_1]);
+
+  waitUntil_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* ExtendableEvent */, "waitUntil", []);
+
+  waitUntil_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* ExtendableEvent */, "waitUntil", [__arg_0]);
+}
+
+class BlinkFederatedCredential extends BlinkCredential {
+  static final instance = new BlinkFederatedCredential();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FederatedCredential");
+
+  constructorCallback_1_(__arg_0) => Blink_JsNative_DomException
+      .callConstructor("FederatedCredential", [__arg_0]);
+
+  protocol_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FederatedCredential */, "protocol");
+
+  provider_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FederatedCredential */, "provider");
+}
+
+class BlinkFetchEvent extends BlinkExtendableEvent {
+  static final instance = new BlinkFetchEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FetchEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("FetchEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("FetchEvent", [__arg_0, __arg_1]);
+
+  isReload_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FetchEvent */, "isReload");
+
+  request_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FetchEvent */, "request");
+
+  respondWith_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FetchEvent */, "respondWith", []);
+
+  respondWith_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FetchEvent */, "respondWith", [__arg_0]);
+}
+
+class BlinkFile extends BlinkBlob {
+  static final instance = new BlinkFile();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("File");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("File", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callConstructor("File", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("File", [__arg_0, __arg_1, __arg_2]);
+
+  lastModified_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* File */, "lastModified");
+
+  lastModifiedDate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* File */, "lastModifiedDate");
+
+  name_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* File */, "name");
+
+  webkitRelativePath_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* File */, "webkitRelativePath");
+}
+
+class BlinkFileCallback {
+  static final instance = new BlinkFileCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkFileEntry extends BlinkEntry {
+  static final instance = new BlinkFileEntry();
+
+  createWriter_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntry */, "createWriter", []);
+
+  createWriter_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntry */, "createWriter", [__arg_0]);
+
+  createWriter_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* FileEntry */, "createWriter", [__arg_0, __arg_1]);
+
+  file_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FileEntry */, "file", []);
+
+  file_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntry */, "file", [__arg_0]);
+
+  file_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntry */, "file", [__arg_0, __arg_1]);
+}
+
+class BlinkFileEntrySync extends BlinkEntrySync {
+  static final instance = new BlinkFileEntrySync();
+
+  createWriter_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntrySync */, "createWriter", []);
+
+  file_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileEntrySync */, "file", []);
+}
+
+class BlinkFileError extends BlinkDOMError {
+  static final instance = new BlinkFileError();
+
+  code_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileError */, "code");
+}
+
+class BlinkFileList {
+  static final instance = new BlinkFileList();
+
+  length_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileList */, "length");
+
+  item_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FileList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileList */, "item", [__arg_0]);
+}
+
+class BlinkFileReader extends BlinkEventTarget {
+  static final instance = new BlinkFileReader();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FileReader");
+
+  error_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileReader */, "error");
+
+  onabort_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "onabort");
+
+  onabort_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileReader */, "onabort", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileReader */, "onerror", __arg_0);
+
+  onload_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileReader */, "onload");
+
+  onload_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileReader */, "onload", __arg_0);
+
+  onloadend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "onloadend");
+
+  onloadend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileReader */, "onloadend", __arg_0);
+
+  onloadstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "onloadstart");
+
+  onloadstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FileReader */, "onloadstart", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileReader */, "onprogress", __arg_0);
+
+  readyState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileReader */, "readyState");
+
+  result_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileReader */, "result");
+
+  abort_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "abort", []);
+
+  readAsArrayBuffer_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsArrayBuffer", []);
+
+  readAsArrayBuffer_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsArrayBuffer", [__arg_0]);
+
+  readAsBinaryString_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsBinaryString", []);
+
+  readAsBinaryString_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsBinaryString", [__arg_0]);
+
+  readAsDataURL_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsDataURL", []);
+
+  readAsDataURL_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsDataURL", [__arg_0]);
+
+  readAsText_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsText", []);
+
+  readAsText_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsText", [__arg_0]);
+
+  readAsText_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReader */, "readAsText", [__arg_0, __arg_1]);
+}
+
+class BlinkFileReaderSync {
+  static final instance = new BlinkFileReaderSync();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FileReaderSync");
+
+  readAsArrayBuffer_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsArrayBuffer", []);
+
+  readAsArrayBuffer_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsArrayBuffer", [__arg_0]);
+
+  readAsBinaryString_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsBinaryString", []);
+
+  readAsBinaryString_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsBinaryString", [__arg_0]);
+
+  readAsDataURL_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsDataURL", []);
+
+  readAsDataURL_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsDataURL", [__arg_0]);
+
+  readAsText_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsText", []);
+
+  readAsText_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsText", [__arg_0]);
+
+  readAsText_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileReaderSync */, "readAsText", [__arg_0, __arg_1]);
+}
+
+class BlinkFileSystemCallback {
+  static final instance = new BlinkFileSystemCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileSystemCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileSystemCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkFileWriter extends BlinkEventTarget {
+  static final instance = new BlinkFileWriter();
+
+  error_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileWriter */, "error");
+
+  length_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FileWriter */, "length");
+
+  onabort_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onabort");
+
+  onabort_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileWriter */, "onabort", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileWriter */, "onerror", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileWriter */, "onprogress", __arg_0);
+
+  onwrite_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onwrite");
+
+  onwrite_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileWriter */, "onwrite", __arg_0);
+
+  onwriteend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onwriteend");
+
+  onwriteend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FileWriter */, "onwriteend", __arg_0);
+
+  onwritestart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "onwritestart");
+
+  onwritestart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FileWriter */, "onwritestart", __arg_0);
+
+  position_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "position");
+
+  readyState_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriter */, "readyState");
+
+  abort_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "abort", []);
+
+  seek_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "seek", []);
+
+  seek_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "seek", [__arg_0]);
+
+  truncate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "truncate", []);
+
+  truncate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "truncate", [__arg_0]);
+
+  write_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "write", []);
+
+  write_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriter */, "write", [__arg_0]);
+}
+
+class BlinkFileWriterCallback {
+  static final instance = new BlinkFileWriterCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkFileWriterSync {
+  static final instance = new BlinkFileWriterSync();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriterSync */, "length");
+
+  position_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FileWriterSync */, "position");
+
+  seek_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "seek", []);
+
+  seek_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "seek", [__arg_0]);
+
+  truncate_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "truncate", []);
+
+  truncate_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "truncate", [__arg_0]);
+
+  write_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "write", []);
+
+  write_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FileWriterSync */, "write", [__arg_0]);
+}
+
+class BlinkFloat32Array extends BlinkArrayBufferView {
+  static final instance = new BlinkFloat32Array();
+}
+
+class BlinkFloat64Array extends BlinkArrayBufferView {
+  static final instance = new BlinkFloat64Array();
+}
+
+class BlinkFocusEvent extends BlinkUIEvent {
+  static final instance = new BlinkFocusEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FocusEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("FocusEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("FocusEvent", [__arg_0, __arg_1]);
+
+  relatedTarget_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FocusEvent */, "relatedTarget");
+}
+
+class BlinkFontFace {
+  static final instance = new BlinkFontFace();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FontFace");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("FontFace", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("FontFace", [__arg_0, __arg_1]);
+
+  constructorCallback_3_(__arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callConstructor("FontFace", [__arg_0, __arg_1, __arg_2]);
+
+  family_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "family");
+
+  family_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFace */, "family", __arg_0);
+
+  featureSettings_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFace */, "featureSettings");
+
+  featureSettings_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FontFace */, "featureSettings", __arg_0);
+
+  loaded_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "loaded");
+
+  status_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "status");
+
+  stretch_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "stretch");
+
+  stretch_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFace */, "stretch", __arg_0);
+
+  style_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "style");
+
+  style_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFace */, "style", __arg_0);
+
+  unicodeRange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFace */, "unicodeRange");
+
+  unicodeRange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FontFace */, "unicodeRange", __arg_0);
+
+  variant_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "variant");
+
+  variant_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFace */, "variant", __arg_0);
+
+  weight_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFace */, "weight");
+
+  weight_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFace */, "weight", __arg_0);
+
+  load_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FontFace */, "load", []);
+}
+
+class BlinkFontFaceSet extends BlinkEventTarget {
+  static final instance = new BlinkFontFaceSet();
+
+  onloading_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFaceSet */, "onloading");
+
+  onloading_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* FontFaceSet */, "onloading", __arg_0);
+
+  onloadingdone_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFaceSet */, "onloadingdone");
+
+  onloadingdone_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FontFaceSet */, "onloadingdone", __arg_0);
+
+  onloadingerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFaceSet */, "onloadingerror");
+
+  onloadingerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* FontFaceSet */, "onloadingerror", __arg_0);
+
+  ready_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFaceSet */, "ready");
+
+  size_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* FontFaceSet */, "size");
+
+  status_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFaceSet */, "status");
+
+  add_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "add", []);
+
+  add_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "add", [__arg_0]);
+
+  check_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "check", []);
+
+  check_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "check", [__arg_0]);
+
+  check_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "check", [__arg_0, __arg_1]);
+
+  clear_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "clear", []);
+
+  delete_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "delete", []);
+
+  delete_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "delete", [__arg_0]);
+
+  forEach_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "forEach", []);
+
+  forEach_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "forEach", [__arg_0]);
+
+  forEach_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "forEach", [__arg_0, __arg_1]);
+
+  has_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "has", []);
+
+  has_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "has", [__arg_0]);
+
+  load_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "load", []);
+
+  load_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "load", [__arg_0]);
+
+  load_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FontFaceSet */, "load", [__arg_0, __arg_1]);
+}
+
+class BlinkFontFaceSetForEachCallback {
+  static final instance = new BlinkFontFaceSetForEachCallback();
+
+  handleItem_Callback_1_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* FontFaceSetForEachCallback */, "handleItem", [__arg_0]);
+
+  handleItem_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* FontFaceSetForEachCallback */,
+          "handleItem",
+          [__arg_0, __arg_1]);
+
+  handleItem_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* FontFaceSetForEachCallback */,
+          "handleItem",
+          [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkFontFaceSetLoadEvent extends BlinkEvent {
+  static final instance = new BlinkFontFaceSetLoadEvent();
+
+  fontfaces_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* FontFaceSetLoadEvent */, "fontfaces");
+}
+
+class BlinkFormData {
+  static final instance = new BlinkFormData();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("FormData");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("FormData", [__arg_0]);
+
+  append_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "append", []);
+
+  append_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "append", [__arg_0]);
+
+  append_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "append", [__arg_0, __arg_1]);
+
+  append_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* FormData */, "append", [__arg_0, __arg_1, __arg_2]);
+
+  delete_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "delete", []);
+
+  delete_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "delete", [__arg_0]);
+
+  get_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FormData */, "get", []);
+
+  get_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "get", [__arg_0]);
+
+  getAll_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "getAll", []);
+
+  getAll_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "getAll", [__arg_0]);
+
+  has_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FormData */, "has", []);
+
+  has_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "has", [__arg_0]);
+
+  set_Callback_0_(mthis) =>
+      Blink_JsNative_DomException.callMethod(mthis /* FormData */, "set", []);
+
+  set_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "set", [__arg_0]);
+
+  set_Callback_2_(mthis, __arg_0, __arg_1) => Blink_JsNative_DomException
+      .callMethod(mthis /* FormData */, "set", [__arg_0, __arg_1]);
+
+  set_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException
+          .callMethod(mthis /* FormData */, "set", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkFrameRequestCallback {
+  static final instance = new BlinkFrameRequestCallback();
+
+  handleEvent_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* FrameRequestCallback */, "handleEvent", []);
+
+  handleEvent_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* FrameRequestCallback */, "handleEvent", [__arg_0]);
+}
+
+class BlinkGainNode extends BlinkAudioNode {
+  static final instance = new BlinkGainNode();
+
+  gain_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* GainNode */, "gain");
+}
+
+class BlinkGamepad {
+  static final instance = new BlinkGamepad();
+
+  axes_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "axes");
+
+  buttons_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "buttons");
+
+  connected_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "connected");
+
+  id_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "id");
+
+  index_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "index");
+
+  mapping_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "mapping");
+
+  timestamp_Getter_(mthis) =>
+      Blink_JsNative_DomException.getProperty(mthis /* Gamepad */, "timestamp");
+}
+
+class BlinkGamepadButton {
+  static final instance = new BlinkGamepadButton();
+
+  pressed_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GamepadButton */, "pressed");
+
+  value_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GamepadButton */, "value");
+}
+
+class BlinkGamepadEvent extends BlinkEvent {
+  static final instance = new BlinkGamepadEvent();
+
+  constructorCallback_0_() =>
+      Blink_JsNative_DomException.callConstructor0("GamepadEvent");
+
+  constructorCallback_1_(__arg_0) =>
+      Blink_JsNative_DomException.callConstructor("GamepadEvent", [__arg_0]);
+
+  constructorCallback_2_(__arg_0, __arg_1) => Blink_JsNative_DomException
+      .callConstructor("GamepadEvent", [__arg_0, __arg_1]);
+
+  gamepad_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GamepadEvent */, "gamepad");
+}
+
+class BlinkGamepadList {
+  static final instance = new BlinkGamepadList();
+
+  length_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GamepadList */, "length");
+
+  item_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* GamepadList */, "item", []);
+
+  item_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* GamepadList */, "item", [__arg_0]);
+}
+
+class BlinkGeofencing {
+  static final instance = new BlinkGeofencing();
+
+  getRegisteredRegions_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geofencing */, "getRegisteredRegions", []);
+
+  registerRegion_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geofencing */, "registerRegion", []);
+
+  registerRegion_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geofencing */, "registerRegion", [__arg_0]);
+
+  unregisterRegion_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geofencing */, "unregisterRegion", []);
+
+  unregisterRegion_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geofencing */, "unregisterRegion", [__arg_0]);
+}
+
+class BlinkGeofencingEvent extends BlinkEvent {
+  static final instance = new BlinkGeofencingEvent();
+
+  id_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GeofencingEvent */, "id");
+
+  region_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GeofencingEvent */, "region");
+}
+
+class BlinkGeofencingRegion {
+  static final instance = new BlinkGeofencingRegion();
+
+  id_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GeofencingRegion */, "id");
+}
+
+class BlinkGeolocation {
+  static final instance = new BlinkGeolocation();
+
+  clearWatch_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "clearWatch", []);
+
+  clearWatch_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "clearWatch", [__arg_0]);
+
+  getCurrentPosition_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "getCurrentPosition", []);
+
+  getCurrentPosition_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "getCurrentPosition", [__arg_0]);
+
+  getCurrentPosition_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Geolocation */, "getCurrentPosition", [__arg_0, __arg_1]);
+
+  getCurrentPosition_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Geolocation */,
+          "getCurrentPosition", [__arg_0, __arg_1, __arg_2]);
+
+  watchPosition_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "watchPosition", []);
+
+  watchPosition_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* Geolocation */, "watchPosition", [__arg_0]);
+
+  watchPosition_Callback_2_(mthis, __arg_0, __arg_1) =>
+      Blink_JsNative_DomException.callMethod(
+          mthis /* Geolocation */, "watchPosition", [__arg_0, __arg_1]);
+
+  watchPosition_Callback_3_(mthis, __arg_0, __arg_1, __arg_2) =>
+      Blink_JsNative_DomException.callMethod(mthis /* Geolocation */,
+          "watchPosition", [__arg_0, __arg_1, __arg_2]);
+}
+
+class BlinkGeoposition {
+  static final instance = new BlinkGeoposition();
+
+  coords_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Geoposition */, "coords");
+
+  timestamp_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* Geoposition */, "timestamp");
+}
+
+class BlinkGlobalEventHandlers {
+  static final instance = new BlinkGlobalEventHandlers();
+
+  onabort_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onabort");
+
+  onabort_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onabort", __arg_0);
+
+  onautocomplete_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocomplete");
+
+  onautocomplete_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onautocomplete", __arg_0);
+
+  onautocompleteerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onautocompleteerror");
+
+  onautocompleteerror_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onautocompleteerror", __arg_0);
+
+  onblur_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onblur");
+
+  onblur_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onblur", __arg_0);
+
+  oncancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncancel");
+
+  oncancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncancel", __arg_0);
+
+  oncanplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay");
+
+  oncanplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oncanplay", __arg_0);
+
+  oncanplaythrough_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncanplaythrough");
+
+  oncanplaythrough_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "oncanplaythrough", __arg_0);
+
+  onchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onchange");
+
+  onchange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onchange", __arg_0);
+
+  onclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclick");
+
+  onclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclick", __arg_0);
+
+  onclose_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onclose");
+
+  onclose_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onclose", __arg_0);
+
+  oncontextmenu_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncontextmenu");
+
+  oncontextmenu_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncontextmenu", __arg_0);
+
+  oncuechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oncuechange");
+
+  oncuechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "oncuechange", __arg_0);
+
+  ondblclick_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick");
+
+  ondblclick_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondblclick", __arg_0);
+
+  ondrag_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrag");
+
+  ondrag_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrag", __arg_0);
+
+  ondragend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragend");
+
+  ondragend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragend", __arg_0);
+
+  ondragenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragenter");
+
+  ondragenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragenter", __arg_0);
+
+  ondragleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragleave");
+
+  ondragleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragleave", __arg_0);
+
+  ondragover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragover");
+
+  ondragover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondragover", __arg_0);
+
+  ondragstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondragstart");
+
+  ondragstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ondragstart", __arg_0);
+
+  ondrop_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondrop");
+
+  ondrop_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ondrop", __arg_0);
+
+  ondurationchange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ondurationchange");
+
+  ondurationchange_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "ondurationchange", __arg_0);
+
+  onemptied_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onemptied");
+
+  onemptied_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onemptied", __arg_0);
+
+  onended_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onended");
+
+  onended_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onended", __arg_0);
+
+  onerror_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onerror");
+
+  onerror_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onerror", __arg_0);
+
+  onfocus_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onfocus");
+
+  onfocus_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onfocus", __arg_0);
+
+  oninput_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninput");
+
+  oninput_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninput", __arg_0);
+
+  oninvalid_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid");
+
+  oninvalid_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "oninvalid", __arg_0);
+
+  onkeydown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown");
+
+  onkeydown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeydown", __arg_0);
+
+  onkeypress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress");
+
+  onkeypress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeypress", __arg_0);
+
+  onkeyup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup");
+
+  onkeyup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onkeyup", __arg_0);
+
+  onload_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onload");
+
+  onload_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onload", __arg_0);
+
+  onloadeddata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadeddata");
+
+  onloadeddata_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadeddata", __arg_0);
+
+  onloadedmetadata_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadedmetadata");
+
+  onloadedmetadata_Setter_(mthis, __arg_0) =>
+      Blink_JsNative_DomException.setProperty(
+          mthis /* GlobalEventHandlers */, "onloadedmetadata", __arg_0);
+
+  onloadstart_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onloadstart");
+
+  onloadstart_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onloadstart", __arg_0);
+
+  onmousedown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousedown");
+
+  onmousedown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousedown", __arg_0);
+
+  onmouseenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseenter");
+
+  onmouseenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseenter", __arg_0);
+
+  onmouseleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseleave");
+
+  onmouseleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseleave", __arg_0);
+
+  onmousemove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousemove");
+
+  onmousemove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousemove", __arg_0);
+
+  onmouseout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout");
+
+  onmouseout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseout", __arg_0);
+
+  onmouseover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseover");
+
+  onmouseover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmouseover", __arg_0);
+
+  onmouseup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup");
+
+  onmouseup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onmouseup", __arg_0);
+
+  onmousewheel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onmousewheel");
+
+  onmousewheel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onmousewheel", __arg_0);
+
+  onpause_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpause");
+
+  onpause_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onpause", __arg_0);
+
+  onplay_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplay");
+
+  onplay_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplay", __arg_0);
+
+  onplaying_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onplaying");
+
+  onplaying_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onplaying", __arg_0);
+
+  onpointercancel_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointercancel");
+
+  onpointercancel_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointercancel", __arg_0);
+
+  onpointerdown_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerdown");
+
+  onpointerdown_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerdown", __arg_0);
+
+  onpointerenter_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerenter");
+
+  onpointerenter_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerenter", __arg_0);
+
+  onpointerleave_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerleave");
+
+  onpointerleave_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerleave", __arg_0);
+
+  onpointermove_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointermove");
+
+  onpointermove_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointermove", __arg_0);
+
+  onpointerout_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerout");
+
+  onpointerout_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerout", __arg_0);
+
+  onpointerover_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerover");
+
+  onpointerover_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerover", __arg_0);
+
+  onpointerup_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onpointerup");
+
+  onpointerup_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onpointerup", __arg_0);
+
+  onprogress_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onprogress");
+
+  onprogress_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onprogress", __arg_0);
+
+  onratechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onratechange");
+
+  onratechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onratechange", __arg_0);
+
+  onreset_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onreset");
+
+  onreset_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onreset", __arg_0);
+
+  onresize_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onresize");
+
+  onresize_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onresize", __arg_0);
+
+  onscroll_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onscroll");
+
+  onscroll_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onscroll", __arg_0);
+
+  onseeked_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeked");
+
+  onseeked_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeked", __arg_0);
+
+  onseeking_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onseeking");
+
+  onseeking_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onseeking", __arg_0);
+
+  onselect_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onselect");
+
+  onselect_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onselect", __arg_0);
+
+  onshow_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onshow");
+
+  onshow_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onshow", __arg_0);
+
+  onstalled_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onstalled");
+
+  onstalled_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onstalled", __arg_0);
+
+  onsubmit_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit");
+
+  onsubmit_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsubmit", __arg_0);
+
+  onsuspend_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend");
+
+  onsuspend_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onsuspend", __arg_0);
+
+  ontimeupdate_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontimeupdate");
+
+  ontimeupdate_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "ontimeupdate", __arg_0);
+
+  ontoggle_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle");
+
+  ontoggle_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "ontoggle", __arg_0);
+
+  onvolumechange_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onvolumechange");
+
+  onvolumechange_Setter_(mthis, __arg_0) => Blink_JsNative_DomException
+      .setProperty(mthis /* GlobalEventHandlers */, "onvolumechange", __arg_0);
+
+  onwaiting_Getter_(mthis) => Blink_JsNative_DomException.getProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting");
+
+  onwaiting_Setter_(mthis, __arg_0) => Blink_JsNative_DomException.setProperty(
+      mthis /* GlobalEventHandlers */, "onwaiting", __arg_0);
+}
+
+class BlinkHMDVRDevice extends BlinkVRDevice {
+  static final instance = new BlinkHMDVRDevice();
+
+  getEyeParameters_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* HMDVRDevice */, "getEyeParameters", []);
+
+  getEyeParameters_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* HMDVRDevice */, "getEyeParameters", [__arg_0]);
+
+  setFieldOfView_Callback_0_(mthis) => Blink_JsNative_DomException
+      .callMethod(mthis /* HMDVRDevice */, "setFieldOfView", []);
+
+  setFieldOfView_Callback_1_(mthis, __arg_0) => Blink_JsNative_DomException
+      .callMethod(mthis /* HMDVRDevice */, "setFieldOfView", [__arg_0]);
+
+